[PATCH v2 0/5] MR8901: winevulkan: Simplify struct conversion and struct extension enumerations.

[Rémi Bernon (＠rbernon)]

--
  v2: winevulkan: Avoid converting unexposed extensions structs.
      winevulkan: Enumerate struct extensions with the registry structs.
      winevulkan: Build the struct extension list lazily.
      winevulkan: Simplify struct conversion enumeration.
      winevulkan: Order the win32 structs as other structs.

https://gitlab.winehq.org/wine/wine/-/merge_requests/8901

[PATCH v2 1/5] winevulkan: Order the win32 structs as other structs.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/winevulkan/make_vulkan     |     6 +-
 dlls/winevulkan/vulkan_thunks.c | 11682 +++++++++++++++---------------
 2 files changed, 5846 insertions(+), 5842 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 09d450bba71..9be7ef8ca66 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -2614,7 +2614,11 @@ class VkGenerator(object):

f.write("WINE_DEFAULT_DEBUG_CHANNEL(vulkan);\n\n")

-        for struct in self.win32_structs:
+        def unique(list, key=lambda x: x, seen=set()):
+            return (e for e in list if not (key(e) in seen or seen.add(key(e))))
+
+        win32_structs = sorted(self.win32_structs, key=lambda struct: (-struct.order, struct.name))
+        for struct in unique(win32_structs, key=lambda struct: struct.name):
             f.write(struct.definition(conv=True, align=True))
             f.write("\n")

diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index 3d8882c8db0..dfd1d57e7d6 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -27,470 +27,679 @@

WINE_DEFAULT_DEBUG_CHANNEL(vulkan);

-typedef struct VkAcquireNextImageInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
-    uint64_t DECLSPEC_ALIGN(8) timeout;
-    VkSemaphore DECLSPEC_ALIGN(8) semaphore;
-    VkFence DECLSPEC_ALIGN(8) fence;
-    uint32_t deviceMask;
-} VkAcquireNextImageInfoKHR32;
-
-typedef struct VkPerformanceConfigurationAcquireInfoINTEL32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkPerformanceConfigurationTypeINTEL type;
-} VkPerformanceConfigurationAcquireInfoINTEL32;
-
-typedef struct VkAcquireProfilingLockInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkAcquireProfilingLockFlagsKHR flags;
-    uint64_t DECLSPEC_ALIGN(8) timeout;
-} VkAcquireProfilingLockInfoKHR32;
-
-typedef struct VkCommandBufferAllocateInfo32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkCommandPool DECLSPEC_ALIGN(8) commandPool;
-    VkCommandBufferLevel level;
-    uint32_t commandBufferCount;
-} VkCommandBufferAllocateInfo32;
-
-typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    uint32_t descriptorSetCount;
-    PTR32 pDescriptorCounts;
-} VkDescriptorSetVariableDescriptorCountAllocateInfo32;
-typedef VkDescriptorSetVariableDescriptorCountAllocateInfo32 VkDescriptorSetVariableDescriptorCountAllocateInfoEXT32;
-
-typedef struct VkDescriptorSetAllocateInfo32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
-    uint32_t descriptorSetCount;
-    PTR32 pSetLayouts;
-} VkDescriptorSetAllocateInfo32;
-
-typedef struct VkDedicatedAllocationMemoryAllocateInfoNV32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkImage DECLSPEC_ALIGN(8) image;
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-} VkDedicatedAllocationMemoryAllocateInfoNV32;
-
-typedef struct VkExportMemoryAllocateInfo32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkExternalMemoryHandleTypeFlags handleTypes;
-} VkExportMemoryAllocateInfo32;
-typedef VkExportMemoryAllocateInfo32 VkExportMemoryAllocateInfoKHR32;
-
-typedef struct VkImportMemoryWin32HandleInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkExternalMemoryHandleTypeFlagBits handleType;
-    HANDLE handle;
-    LPCWSTR name;
-} VkImportMemoryWin32HandleInfoKHR32;
-
-typedef struct VkExportMemoryWin32HandleInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    PTR32 pAttributes;
-    DWORD dwAccess;
-    LPCWSTR name;
-} VkExportMemoryWin32HandleInfoKHR32;
-
-typedef struct VkMemoryAllocateFlagsInfo32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkMemoryAllocateFlags flags;
-    uint32_t deviceMask;
-} VkMemoryAllocateFlagsInfo32;
-typedef VkMemoryAllocateFlagsInfo32 VkMemoryAllocateFlagsInfoKHR32;
-
-typedef struct VkMemoryDedicatedAllocateInfo32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkImage DECLSPEC_ALIGN(8) image;
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-} VkMemoryDedicatedAllocateInfo32;
-typedef VkMemoryDedicatedAllocateInfo32 VkMemoryDedicatedAllocateInfoKHR32;
-
-typedef struct VkImportMemoryHostPointerInfoEXT32
+typedef struct VkGeometryAABBNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalMemoryHandleTypeFlagBits handleType;
-    PTR32 pHostPointer;
-} VkImportMemoryHostPointerInfoEXT32;
+    VkBuffer DECLSPEC_ALIGN(8) aabbData;
+    uint32_t numAABBs;
+    uint32_t stride;
+    VkDeviceSize DECLSPEC_ALIGN(8) offset;
+} VkGeometryAABBNV32;

-typedef struct VkMemoryPriorityAllocateInfoEXT32
+typedef struct VkGeometryTrianglesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    float priority;
-} VkMemoryPriorityAllocateInfoEXT32;
+    VkBuffer DECLSPEC_ALIGN(8) vertexData;
+    VkDeviceSize DECLSPEC_ALIGN(8) vertexOffset;
+    uint32_t vertexCount;
+    VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
+    VkFormat vertexFormat;
+    VkBuffer DECLSPEC_ALIGN(8) indexData;
+    VkDeviceSize DECLSPEC_ALIGN(8) indexOffset;
+    uint32_t indexCount;
+    VkIndexType indexType;
+    VkBuffer DECLSPEC_ALIGN(8) transformData;
+    VkDeviceSize DECLSPEC_ALIGN(8) transformOffset;
+} VkGeometryTrianglesNV32;

-typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo32
+typedef struct VkSpecializationMapEntry32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
-} VkMemoryOpaqueCaptureAddressAllocateInfo32;
-typedef VkMemoryOpaqueCaptureAddressAllocateInfo32 VkMemoryOpaqueCaptureAddressAllocateInfoKHR32;
+    uint32_t constantID;
+    uint32_t offset;
+    PTR32 size;
+} VkSpecializationMapEntry32;

-typedef struct VkMemoryDedicatedAllocateInfoTensorARM32
+typedef struct StdVideoH264SequenceParameterSetVui32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkTensorARM DECLSPEC_ALIGN(8) tensor;
-} VkMemoryDedicatedAllocateInfoTensorARM32;
+    StdVideoH264SpsVuiFlags flags;
+    StdVideoH264AspectRatioIdc aspect_ratio_idc;
+    uint16_t sar_width;
+    uint16_t sar_height;
+    uint8_t video_format;
+    uint8_t colour_primaries;
+    uint8_t transfer_characteristics;
+    uint8_t matrix_coefficients;
+    uint32_t num_units_in_tick;
+    uint32_t time_scale;
+    uint8_t max_num_reorder_frames;
+    uint8_t max_dec_frame_buffering;
+    uint8_t chroma_sample_loc_type_top_field;
+    uint8_t chroma_sample_loc_type_bottom_field;
+    uint32_t reserved1;
+    PTR32 pHrdParameters;
+} StdVideoH264SequenceParameterSetVui32;

-typedef struct VkMemoryAllocateInfo32
+typedef struct VkAccelerationStructureGeometryAabbsDataKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) allocationSize;
-    uint32_t memoryTypeIndex;
-} VkMemoryAllocateInfo32;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
+    VkDeviceSize DECLSPEC_ALIGN(8) stride;
+} VkAccelerationStructureGeometryAabbsDataKHR32;

-typedef struct VkAntiLagPresentationInfoAMD32
+typedef struct VkAccelerationStructureGeometryInstancesDataKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAntiLagStageAMD stage;
-    uint64_t DECLSPEC_ALIGN(8) frameIndex;
-} VkAntiLagPresentationInfoAMD32;
+    VkBool32 arrayOfPointers;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
+} VkAccelerationStructureGeometryInstancesDataKHR32;

-typedef struct VkAntiLagDataAMD32
+typedef struct VkAccelerationStructureGeometryTrianglesDataKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAntiLagModeAMD mode;
-    uint32_t maxFPS;
-    PTR32 pPresentationInfo;
-} VkAntiLagDataAMD32;
+    VkFormat vertexFormat;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData;
+    VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
+    uint32_t maxVertex;
+    VkIndexType indexType;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) transformData;
+} VkAccelerationStructureGeometryTrianglesDataKHR32;

-typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT32
+typedef struct VkClusterAccelerationStructureClustersBottomLevelInputNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 conditionalRenderingEnable;
-} VkCommandBufferInheritanceConditionalRenderingInfoEXT32;
+    uint32_t maxTotalClusterCount;
+    uint32_t maxClusterCountPerAccelerationStructure;
+} VkClusterAccelerationStructureClustersBottomLevelInputNV32;

-typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM32
+typedef struct VkClusterAccelerationStructureMoveObjectsInputNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSurfaceTransformFlagBitsKHR transform;
-    VkRect2D renderArea;
-} VkCommandBufferInheritanceRenderPassTransformInfoQCOM32;
+    VkClusterAccelerationStructureTypeNV type;
+    VkBool32 noMoveOverlap;
+    VkDeviceSize DECLSPEC_ALIGN(8) maxMovedBytes;
+} VkClusterAccelerationStructureMoveObjectsInputNV32;

-typedef struct VkCommandBufferInheritanceViewportScissorInfoNV32
+typedef struct VkClusterAccelerationStructureTriangleClusterInputNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 viewportScissor2D;
-    uint32_t viewportDepthCount;
-    PTR32 pViewportDepths;
-} VkCommandBufferInheritanceViewportScissorInfoNV32;
+    VkFormat vertexFormat;
+    uint32_t maxGeometryIndexValue;
+    uint32_t maxClusterUniqueGeometryCount;
+    uint32_t maxClusterTriangleCount;
+    uint32_t maxClusterVertexCount;
+    uint32_t maxTotalTriangleCount;
+    uint32_t maxTotalVertexCount;
+    uint32_t minPositionTruncateBitCount;
+} VkClusterAccelerationStructureTriangleClusterInputNV32;

-typedef struct VkCommandBufferInheritanceRenderingInfo32
+typedef struct VkGeometryDataNV32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkRenderingFlags flags;
-    uint32_t viewMask;
-    uint32_t colorAttachmentCount;
-    PTR32 pColorAttachmentFormats;
-    VkFormat depthAttachmentFormat;
-    VkFormat stencilAttachmentFormat;
-    VkSampleCountFlagBits rasterizationSamples;
-} VkCommandBufferInheritanceRenderingInfo32;
-typedef VkCommandBufferInheritanceRenderingInfo32 VkCommandBufferInheritanceRenderingInfoKHR32;
+    VkGeometryTrianglesNV32 DECLSPEC_ALIGN(8) triangles;
+    VkGeometryAABBNV32 DECLSPEC_ALIGN(8) aabbs;
+} VkGeometryDataNV32;

-typedef struct VkAttachmentSampleCountInfoAMD32
+typedef struct VkIndirectExecutionSetShaderLayoutInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t colorAttachmentCount;
-    PTR32 pColorAttachmentSamples;
-    VkSampleCountFlagBits depthStencilAttachmentSamples;
-} VkAttachmentSampleCountInfoAMD32;
-typedef VkAttachmentSampleCountInfoAMD32 VkAttachmentSampleCountInfoNV32;
+    uint32_t setLayoutCount;
+    PTR32 pSetLayouts;
+} VkIndirectExecutionSetShaderLayoutInfoEXT32;

-typedef struct VkTileMemoryBindInfoQCOM32
+typedef struct VkPhysicalDeviceLimits32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
-} VkTileMemoryBindInfoQCOM32;
+    uint32_t maxImageDimension1D;
+    uint32_t maxImageDimension2D;
+    uint32_t maxImageDimension3D;
+    uint32_t maxImageDimensionCube;
+    uint32_t maxImageArrayLayers;
+    uint32_t maxTexelBufferElements;
+    uint32_t maxUniformBufferRange;
+    uint32_t maxStorageBufferRange;
+    uint32_t maxPushConstantsSize;
+    uint32_t maxMemoryAllocationCount;
+    uint32_t maxSamplerAllocationCount;
+    VkDeviceSize DECLSPEC_ALIGN(8) bufferImageGranularity;
+    VkDeviceSize DECLSPEC_ALIGN(8) sparseAddressSpaceSize;
+    uint32_t maxBoundDescriptorSets;
+    uint32_t maxPerStageDescriptorSamplers;
+    uint32_t maxPerStageDescriptorUniformBuffers;
+    uint32_t maxPerStageDescriptorStorageBuffers;
+    uint32_t maxPerStageDescriptorSampledImages;
+    uint32_t maxPerStageDescriptorStorageImages;
+    uint32_t maxPerStageDescriptorInputAttachments;
+    uint32_t maxPerStageResources;
+    uint32_t maxDescriptorSetSamplers;
+    uint32_t maxDescriptorSetUniformBuffers;
+    uint32_t maxDescriptorSetUniformBuffersDynamic;
+    uint32_t maxDescriptorSetStorageBuffers;
+    uint32_t maxDescriptorSetStorageBuffersDynamic;
+    uint32_t maxDescriptorSetSampledImages;
+    uint32_t maxDescriptorSetStorageImages;
+    uint32_t maxDescriptorSetInputAttachments;
+    uint32_t maxVertexInputAttributes;
+    uint32_t maxVertexInputBindings;
+    uint32_t maxVertexInputAttributeOffset;
+    uint32_t maxVertexInputBindingStride;
+    uint32_t maxVertexOutputComponents;
+    uint32_t maxTessellationGenerationLevel;
+    uint32_t maxTessellationPatchSize;
+    uint32_t maxTessellationControlPerVertexInputComponents;
+    uint32_t maxTessellationControlPerVertexOutputComponents;
+    uint32_t maxTessellationControlPerPatchOutputComponents;
+    uint32_t maxTessellationControlTotalOutputComponents;
+    uint32_t maxTessellationEvaluationInputComponents;
+    uint32_t maxTessellationEvaluationOutputComponents;
+    uint32_t maxGeometryShaderInvocations;
+    uint32_t maxGeometryInputComponents;
+    uint32_t maxGeometryOutputComponents;
+    uint32_t maxGeometryOutputVertices;
+    uint32_t maxGeometryTotalOutputComponents;
+    uint32_t maxFragmentInputComponents;
+    uint32_t maxFragmentOutputAttachments;
+    uint32_t maxFragmentDualSrcAttachments;
+    uint32_t maxFragmentCombinedOutputResources;
+    uint32_t maxComputeSharedMemorySize;
+    uint32_t maxComputeWorkGroupCount[3];
+    uint32_t maxComputeWorkGroupInvocations;
+    uint32_t maxComputeWorkGroupSize[3];
+    uint32_t subPixelPrecisionBits;
+    uint32_t subTexelPrecisionBits;
+    uint32_t mipmapPrecisionBits;
+    uint32_t maxDrawIndexedIndexValue;
+    uint32_t maxDrawIndirectCount;
+    float maxSamplerLodBias;
+    float maxSamplerAnisotropy;
+    uint32_t maxViewports;
+    uint32_t maxViewportDimensions[2];
+    float viewportBoundsRange[2];
+    uint32_t viewportSubPixelBits;
+    PTR32 minMemoryMapAlignment;
+    VkDeviceSize DECLSPEC_ALIGN(8) minTexelBufferOffsetAlignment;
+    VkDeviceSize DECLSPEC_ALIGN(8) minUniformBufferOffsetAlignment;
+    VkDeviceSize DECLSPEC_ALIGN(8) minStorageBufferOffsetAlignment;
+    int32_t minTexelOffset;
+    uint32_t maxTexelOffset;
+    int32_t minTexelGatherOffset;
+    uint32_t maxTexelGatherOffset;
+    float minInterpolationOffset;
+    float maxInterpolationOffset;
+    uint32_t subPixelInterpolationOffsetBits;
+    uint32_t maxFramebufferWidth;
+    uint32_t maxFramebufferHeight;
+    uint32_t maxFramebufferLayers;
+    VkSampleCountFlags framebufferColorSampleCounts;
+    VkSampleCountFlags framebufferDepthSampleCounts;
+    VkSampleCountFlags framebufferStencilSampleCounts;
+    VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
+    uint32_t maxColorAttachments;
+    VkSampleCountFlags sampledImageColorSampleCounts;
+    VkSampleCountFlags sampledImageIntegerSampleCounts;
+    VkSampleCountFlags sampledImageDepthSampleCounts;
+    VkSampleCountFlags sampledImageStencilSampleCounts;
+    VkSampleCountFlags storageImageSampleCounts;
+    uint32_t maxSampleMaskWords;
+    VkBool32 timestampComputeAndGraphics;
+    float timestampPeriod;
+    uint32_t maxClipDistances;
+    uint32_t maxCullDistances;
+    uint32_t maxCombinedClipAndCullDistances;
+    uint32_t discreteQueuePriorities;
+    float pointSizeRange[2];
+    float lineWidthRange[2];
+    float pointSizeGranularity;
+    float lineWidthGranularity;
+    VkBool32 strictLines;
+    VkBool32 standardSampleLocations;
+    VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyOffsetAlignment;
+    VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyRowPitchAlignment;
+    VkDeviceSize DECLSPEC_ALIGN(8) nonCoherentAtomSize;
+} VkPhysicalDeviceLimits32;

-typedef struct VkRenderingAttachmentLocationInfo32
+typedef struct VkSpecializationInfo32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    uint32_t colorAttachmentCount;
-    PTR32 pColorAttachmentLocations;
-} VkRenderingAttachmentLocationInfo32;
-typedef VkRenderingAttachmentLocationInfo32 VkRenderingAttachmentLocationInfoKHR32;
+    uint32_t mapEntryCount;
+    PTR32 pMapEntries;
+    PTR32 dataSize;
+    PTR32 pData;
+} VkSpecializationInfo32;

-typedef struct VkRenderingInputAttachmentIndexInfo32
+typedef struct StdVideoAV1TileInfo32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    uint32_t colorAttachmentCount;
-    PTR32 pColorAttachmentInputIndices;
-    PTR32 pDepthInputAttachmentIndex;
-    PTR32 pStencilInputAttachmentIndex;
-} VkRenderingInputAttachmentIndexInfo32;
-typedef VkRenderingInputAttachmentIndexInfo32 VkRenderingInputAttachmentIndexInfoKHR32;
+    StdVideoAV1TileInfoFlags flags;
+    uint8_t TileCols;
+    uint8_t TileRows;
+    uint16_t context_update_tile_id;
+    uint8_t tile_size_bytes_minus_1;
+    uint8_t reserved1[7];
+    PTR32 pMiColStarts;
+    PTR32 pMiRowStarts;
+    PTR32 pWidthInSbsMinus1;
+    PTR32 pHeightInSbsMinus1;
+} StdVideoAV1TileInfo32;

-typedef struct VkRenderPassTileShadingCreateInfoQCOM32
+typedef struct StdVideoEncodeH264ReferenceListsInfo32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkTileShadingRenderPassFlagsQCOM flags;
-    VkExtent2D tileApronSize;
-} VkRenderPassTileShadingCreateInfoQCOM32;
+    StdVideoEncodeH264ReferenceListsInfoFlags flags;
+    uint8_t num_ref_idx_l0_active_minus1;
+    uint8_t num_ref_idx_l1_active_minus1;
+    uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF];
+    uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF];
+    uint8_t refList0ModOpCount;
+    uint8_t refList1ModOpCount;
+    uint8_t refPicMarkingOpCount;
+    uint8_t reserved1[7];
+    PTR32 pRefList0ModOperations;
+    PTR32 pRefList1ModOperations;
+    PTR32 pRefPicMarkingOperations;
+} StdVideoEncodeH264ReferenceListsInfo32;

-typedef struct VkCommandBufferInheritanceInfo32
+typedef struct StdVideoEncodeH264SliceHeader32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkRenderPass DECLSPEC_ALIGN(8) renderPass;
-    uint32_t subpass;
-    VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
-    VkBool32 occlusionQueryEnable;
-    VkQueryControlFlags queryFlags;
-    VkQueryPipelineStatisticFlags pipelineStatistics;
-} VkCommandBufferInheritanceInfo32;
+    StdVideoEncodeH264SliceHeaderFlags flags;
+    uint32_t first_mb_in_slice;
+    StdVideoH264SliceType slice_type;
+    int8_t slice_alpha_c0_offset_div2;
+    int8_t slice_beta_offset_div2;
+    int8_t slice_qp_delta;
+    uint8_t reserved1;
+    StdVideoH264CabacInitIdc cabac_init_idc;
+    StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc;
+    PTR32 pWeightTable;
+} StdVideoEncodeH264SliceHeader32;

-typedef struct VkDeviceGroupCommandBufferBeginInfo32
+typedef struct StdVideoH264PictureParameterSet32
+{
+    StdVideoH264PpsFlags flags;
+    uint8_t seq_parameter_set_id;
+    uint8_t pic_parameter_set_id;
+    uint8_t num_ref_idx_l0_default_active_minus1;
+    uint8_t num_ref_idx_l1_default_active_minus1;
+    StdVideoH264WeightedBipredIdc weighted_bipred_idc;
+    int8_t pic_init_qp_minus26;
+    int8_t pic_init_qs_minus26;
+    int8_t chroma_qp_index_offset;
+    int8_t second_chroma_qp_index_offset;
+    PTR32 pScalingLists;
+} StdVideoH264PictureParameterSet32;
+
+typedef struct StdVideoH264SequenceParameterSet32
+{
+    StdVideoH264SpsFlags flags;
+    StdVideoH264ProfileIdc profile_idc;
+    StdVideoH264LevelIdc level_idc;
+    StdVideoH264ChromaFormatIdc chroma_format_idc;
+    uint8_t seq_parameter_set_id;
+    uint8_t bit_depth_luma_minus8;
+    uint8_t bit_depth_chroma_minus8;
+    uint8_t log2_max_frame_num_minus4;
+    StdVideoH264PocType pic_order_cnt_type;
+    int32_t offset_for_non_ref_pic;
+    int32_t offset_for_top_to_bottom_field;
+    uint8_t log2_max_pic_order_cnt_lsb_minus4;
+    uint8_t num_ref_frames_in_pic_order_cnt_cycle;
+    uint8_t max_num_ref_frames;
+    uint8_t reserved1;
+    uint32_t pic_width_in_mbs_minus1;
+    uint32_t pic_height_in_map_units_minus1;
+    uint32_t frame_crop_left_offset;
+    uint32_t frame_crop_right_offset;
+    uint32_t frame_crop_top_offset;
+    uint32_t frame_crop_bottom_offset;
+    uint32_t reserved2;
+    PTR32 pOffsetForRefFrame;
+    PTR32 pScalingLists;
+    PTR32 pSequenceParameterSetVui;
+} StdVideoH264SequenceParameterSet32;
+
+typedef union VkAccelerationStructureGeometryDataKHR32
+{
+    VkAccelerationStructureGeometryTrianglesDataKHR32 DECLSPEC_ALIGN(8) triangles;
+    VkAccelerationStructureGeometryAabbsDataKHR32 DECLSPEC_ALIGN(8) aabbs;
+    VkAccelerationStructureGeometryInstancesDataKHR32 DECLSPEC_ALIGN(8) instances;
+} VkAccelerationStructureGeometryDataKHR32;
+
+typedef struct VkAttachmentReference232
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t deviceMask;
-} VkDeviceGroupCommandBufferBeginInfo32;
-typedef VkDeviceGroupCommandBufferBeginInfo32 VkDeviceGroupCommandBufferBeginInfoKHR32;
+    uint32_t attachment;
+    VkImageLayout layout;
+    VkImageAspectFlags aspectMask;
+} VkAttachmentReference232;
+typedef VkAttachmentReference232 VkAttachmentReference2KHR32;

-typedef struct VkCommandBufferBeginInfo32
+typedef union VkClusterAccelerationStructureOpInputNV32
+{
+    PTR32 pClustersBottomLevel;
+    PTR32 pTriangleClusters;
+    PTR32 pMoveObjects;
+} VkClusterAccelerationStructureOpInputNV32;
+
+typedef struct VkDescriptorAddressInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkCommandBufferUsageFlags flags;
-    PTR32 pInheritanceInfo;
-} VkCommandBufferBeginInfo32;
+    VkDeviceAddress DECLSPEC_ALIGN(8) address;
+    VkDeviceSize DECLSPEC_ALIGN(8) range;
+    VkFormat format;
+} VkDescriptorAddressInfoEXT32;

-typedef struct VkBindAccelerationStructureMemoryInfoNV32
+typedef struct VkDescriptorBufferInfo32
+{
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+    VkDeviceSize DECLSPEC_ALIGN(8) offset;
+    VkDeviceSize DECLSPEC_ALIGN(8) range;
+} VkDescriptorBufferInfo32;
+
+typedef struct VkDescriptorImageInfo32
+{
+    VkSampler DECLSPEC_ALIGN(8) sampler;
+    VkImageView DECLSPEC_ALIGN(8) imageView;
+    VkImageLayout imageLayout;
+} VkDescriptorImageInfo32;
+
+typedef struct VkGeometryNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
-    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
-    VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
-    uint32_t deviceIndexCount;
-    PTR32 pDeviceIndices;
-} VkBindAccelerationStructureMemoryInfoNV32;
+    VkGeometryTypeKHR geometryType;
+    VkGeometryDataNV32 DECLSPEC_ALIGN(8) geometry;
+    VkGeometryFlagsKHR flags;
+} VkGeometryNV32;

-typedef struct VkBindBufferMemoryDeviceGroupInfo32
+typedef struct VkImageCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t deviceIndexCount;
-    PTR32 pDeviceIndices;
-} VkBindBufferMemoryDeviceGroupInfo32;
-typedef VkBindBufferMemoryDeviceGroupInfo32 VkBindBufferMemoryDeviceGroupInfoKHR32;
+    VkImageCreateFlags flags;
+    VkImageType imageType;
+    VkFormat format;
+    VkExtent3D extent;
+    uint32_t mipLevels;
+    uint32_t arrayLayers;
+    VkSampleCountFlagBits samples;
+    VkImageTiling tiling;
+    VkImageUsageFlags usage;
+    VkSharingMode sharingMode;
+    uint32_t queueFamilyIndexCount;
+    PTR32 pQueueFamilyIndices;
+    VkImageLayout initialLayout;
+} VkImageCreateInfo32;

-typedef struct VkBindMemoryStatus32
+typedef union VkIndirectCommandsTokenDataEXT32
+{
+    PTR32 pPushConstant;
+    PTR32 pVertexBuffer;
+    PTR32 pIndexBuffer;
+    PTR32 pExecutionSet;
+} VkIndirectCommandsTokenDataEXT32;
+
+typedef struct VkIndirectExecutionSetPipelineInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pResult;
-} VkBindMemoryStatus32;
-typedef VkBindMemoryStatus32 VkBindMemoryStatusKHR32;
+    VkPipeline DECLSPEC_ALIGN(8) initialPipeline;
+    uint32_t maxPipelineCount;
+} VkIndirectExecutionSetPipelineInfoEXT32;

-typedef struct VkBindBufferMemoryInfo32
+typedef struct VkIndirectExecutionSetShaderInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
-    VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
-} VkBindBufferMemoryInfo32;
-typedef VkBindBufferMemoryInfo32 VkBindBufferMemoryInfoKHR32;
+    uint32_t shaderCount;
+    PTR32 pInitialShaders;
+    PTR32 pSetLayoutInfos;
+    uint32_t maxShaderCount;
+    uint32_t pushConstantRangeCount;
+    PTR32 pPushConstantRanges;
+} VkIndirectExecutionSetShaderInfoEXT32;

-typedef struct VkBindDataGraphPipelineSessionMemoryInfoARM32
+typedef struct VkMemoryHeap32
+{
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+    VkMemoryHeapFlags flags;
+} VkMemoryHeap32;
+
+typedef struct VkPhysicalDeviceProperties32
+{
+    uint32_t apiVersion;
+    uint32_t driverVersion;
+    uint32_t vendorID;
+    uint32_t deviceID;
+    VkPhysicalDeviceType deviceType;
+    char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
+    uint8_t pipelineCacheUUID[VK_UUID_SIZE];
+    VkPhysicalDeviceLimits32 DECLSPEC_ALIGN(8) limits;
+    VkPhysicalDeviceSparseProperties sparseProperties;
+} VkPhysicalDeviceProperties32;
+
+typedef struct VkPipelineBinaryDataKHR32
+{
+    PTR32 dataSize;
+    PTR32 pData;
+} VkPipelineBinaryDataKHR32;
+
+typedef struct VkPipelineBinaryKeyKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session;
-    VkDataGraphPipelineSessionBindPointARM bindPoint;
-    uint32_t objectIndex;
-    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
-    VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
-} VkBindDataGraphPipelineSessionMemoryInfoARM32;
+    uint32_t keySize;
+    uint8_t key[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR];
+} VkPipelineBinaryKeyKHR32;

-typedef struct VkBindImageMemoryDeviceGroupInfo32
+typedef struct VkPipelineShaderStageCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t deviceIndexCount;
-    PTR32 pDeviceIndices;
-    uint32_t splitInstanceBindRegionCount;
-    PTR32 pSplitInstanceBindRegions;
-} VkBindImageMemoryDeviceGroupInfo32;
-typedef VkBindImageMemoryDeviceGroupInfo32 VkBindImageMemoryDeviceGroupInfoKHR32;
+    VkPipelineShaderStageCreateFlags flags;
+    VkShaderStageFlagBits stage;
+    VkShaderModule DECLSPEC_ALIGN(8) module;
+    PTR32 pName;
+    PTR32 pSpecializationInfo;
+} VkPipelineShaderStageCreateInfo32;

-typedef struct VkBindImageMemorySwapchainInfoKHR32
+typedef struct VkPipelineTessellationStateCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
-    uint32_t imageIndex;
-} VkBindImageMemorySwapchainInfoKHR32;
+    VkPipelineTessellationStateCreateFlags flags;
+    uint32_t patchControlPoints;
+} VkPipelineTessellationStateCreateInfo32;

-typedef struct VkBindImagePlaneMemoryInfo32
+typedef struct VkPipelineVertexInputStateCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageAspectFlagBits planeAspect;
-} VkBindImagePlaneMemoryInfo32;
-typedef VkBindImagePlaneMemoryInfo32 VkBindImagePlaneMemoryInfoKHR32;
+    VkPipelineVertexInputStateCreateFlags flags;
+    uint32_t vertexBindingDescriptionCount;
+    PTR32 pVertexBindingDescriptions;
+    uint32_t vertexAttributeDescriptionCount;
+    PTR32 pVertexAttributeDescriptions;
+} VkPipelineVertexInputStateCreateInfo32;

-typedef struct VkBindImageMemoryInfo32
+typedef struct VkSampleLocationsInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImage DECLSPEC_ALIGN(8) image;
-    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
-    VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
-} VkBindImageMemoryInfo32;
-typedef VkBindImageMemoryInfo32 VkBindImageMemoryInfoKHR32;
+    VkSampleCountFlagBits sampleLocationsPerPixel;
+    VkExtent2D sampleLocationGridSize;
+    uint32_t sampleLocationsCount;
+    PTR32 pSampleLocations;
+} VkSampleLocationsInfoEXT32;

-typedef struct VkBindTensorMemoryInfoARM32
+typedef struct VkSparseImageMemoryBind32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkTensorARM DECLSPEC_ALIGN(8) tensor;
+    VkImageSubresource subresource;
+    VkOffset3D offset;
+    VkExtent3D extent;
     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
-} VkBindTensorMemoryInfoARM32;
+    VkSparseMemoryBindFlags flags;
+} VkSparseImageMemoryBind32;

-typedef struct VkBindVideoSessionMemoryInfoKHR32
+typedef struct VkSparseMemoryBind32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    uint32_t memoryBindIndex;
+    VkDeviceSize DECLSPEC_ALIGN(8) resourceOffset;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
-    VkDeviceSize DECLSPEC_ALIGN(8) memorySize;
-} VkBindVideoSessionMemoryInfoKHR32;
+    VkSparseMemoryBindFlags flags;
+} VkSparseMemoryBind32;

-typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV32
+typedef struct VkTensorDescriptionARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData;
-} VkAccelerationStructureGeometryMotionTrianglesDataNV32;
+    VkTensorTilingARM tiling;
+    VkFormat format;
+    uint32_t dimensionCount;
+    PTR32 pDimensions;
+    PTR32 pStrides;
+    VkTensorUsageFlagsARM DECLSPEC_ALIGN(8) usage;
+} VkTensorDescriptionARM32;

-typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT32
+typedef struct VkVideoPictureResourceInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkIndexType indexType;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexBuffer;
-    VkDeviceSize DECLSPEC_ALIGN(8) indexStride;
-    uint32_t baseTriangle;
-    uint32_t usageCountsCount;
-    PTR32 pUsageCounts;
-    PTR32 ppUsageCounts;
-    VkMicromapEXT DECLSPEC_ALIGN(8) micromap;
-} VkAccelerationStructureTrianglesOpacityMicromapEXT32;
+    VkOffset2D codedOffset;
+    VkExtent2D codedExtent;
+    uint32_t baseArrayLayer;
+    VkImageView DECLSPEC_ALIGN(8) imageViewBinding;
+} VkVideoPictureResourceInfoKHR32;

-typedef struct VkAccelerationStructureGeometryTrianglesDataKHR32
+typedef struct StdVideoAV1SequenceHeader32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkFormat vertexFormat;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData;
-    VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
-    uint32_t maxVertex;
-    VkIndexType indexType;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) transformData;
-} VkAccelerationStructureGeometryTrianglesDataKHR32;
+    StdVideoAV1SequenceHeaderFlags flags;
+    StdVideoAV1Profile seq_profile;
+    uint8_t frame_width_bits_minus_1;
+    uint8_t frame_height_bits_minus_1;
+    uint16_t max_frame_width_minus_1;
+    uint16_t max_frame_height_minus_1;
+    uint8_t delta_frame_id_length_minus_2;
+    uint8_t additional_frame_id_length_minus_1;
+    uint8_t order_hint_bits_minus_1;
+    uint8_t seq_force_integer_mv;
+    uint8_t seq_force_screen_content_tools;
+    uint8_t reserved1[5];
+    PTR32 pColorConfig;
+    PTR32 pTimingInfo;
+} StdVideoAV1SequenceHeader32;

-typedef struct VkAccelerationStructureGeometryAabbsDataKHR32
+typedef struct StdVideoDecodeAV1PictureInfo32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
-    VkDeviceSize DECLSPEC_ALIGN(8) stride;
-} VkAccelerationStructureGeometryAabbsDataKHR32;
+    StdVideoDecodeAV1PictureInfoFlags flags;
+    StdVideoAV1FrameType frame_type;
+    uint32_t current_frame_id;
+    uint8_t OrderHint;
+    uint8_t primary_ref_frame;
+    uint8_t refresh_frame_flags;
+    uint8_t reserved1;
+    StdVideoAV1InterpolationFilter interpolation_filter;
+    StdVideoAV1TxMode TxMode;
+    uint8_t delta_q_res;
+    uint8_t delta_lf_res;
+    uint8_t SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES];
+    uint8_t coded_denom;
+    uint8_t reserved2[3];
+    uint8_t OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES];
+    uint32_t expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES];
+    PTR32 pTileInfo;
+    PTR32 pQuantization;
+    PTR32 pSegmentation;
+    PTR32 pLoopFilter;
+    PTR32 pCDEF;
+    PTR32 pLoopRestoration;
+    PTR32 pGlobalMotion;
+    PTR32 pFilmGrain;
+} StdVideoDecodeAV1PictureInfo32;

-typedef struct VkAccelerationStructureGeometryInstancesDataKHR32
+typedef struct StdVideoDecodeVP9PictureInfo32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkBool32 arrayOfPointers;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
-} VkAccelerationStructureGeometryInstancesDataKHR32;
+    StdVideoDecodeVP9PictureInfoFlags flags;
+    StdVideoVP9Profile profile;
+    StdVideoVP9FrameType frame_type;
+    uint8_t frame_context_idx;
+    uint8_t reset_frame_context;
+    uint8_t refresh_frame_flags;
+    uint8_t ref_frame_sign_bias_mask;
+    StdVideoVP9InterpolationFilter interpolation_filter;
+    uint8_t base_q_idx;
+    int8_t delta_q_y_dc;
+    int8_t delta_q_uv_dc;
+    int8_t delta_q_uv_ac;
+    uint8_t tile_cols_log2;
+    uint8_t tile_rows_log2;
+    uint16_t reserved1[3];
+    PTR32 pColorConfig;
+    PTR32 pLoopFilter;
+    PTR32 pSegmentation;
+} StdVideoDecodeVP9PictureInfo32;

-typedef union VkAccelerationStructureGeometryDataKHR32
+typedef struct StdVideoEncodeAV1PictureInfo32
 {
-    VkAccelerationStructureGeometryTrianglesDataKHR32 DECLSPEC_ALIGN(8) triangles;
-    VkAccelerationStructureGeometryAabbsDataKHR32 DECLSPEC_ALIGN(8) aabbs;
-    VkAccelerationStructureGeometryInstancesDataKHR32 DECLSPEC_ALIGN(8) instances;
-} VkAccelerationStructureGeometryDataKHR32;
+    StdVideoEncodeAV1PictureInfoFlags flags;
+    StdVideoAV1FrameType frame_type;
+    uint32_t frame_presentation_time;
+    uint32_t current_frame_id;
+    uint8_t order_hint;
+    uint8_t primary_ref_frame;
+    uint8_t refresh_frame_flags;
+    uint8_t coded_denom;
+    uint16_t render_width_minus_1;
+    uint16_t render_height_minus_1;
+    StdVideoAV1InterpolationFilter interpolation_filter;
+    StdVideoAV1TxMode TxMode;
+    uint8_t delta_q_res;
+    uint8_t delta_lf_res;
+    uint8_t ref_order_hint[STD_VIDEO_AV1_NUM_REF_FRAMES];
+    int8_t ref_frame_idx[STD_VIDEO_AV1_REFS_PER_FRAME];
+    uint8_t reserved1[3];
+    uint32_t delta_frame_id_minus_1[STD_VIDEO_AV1_REFS_PER_FRAME];
+    PTR32 pTileInfo;
+    PTR32 pQuantization;
+    PTR32 pSegmentation;
+    PTR32 pLoopFilter;
+    PTR32 pCDEF;
+    PTR32 pLoopRestoration;
+    PTR32 pGlobalMotion;
+    PTR32 pExtensionHeader;
+    PTR32 pBufferRemovalTimes;
+} StdVideoEncodeAV1PictureInfo32;

-typedef struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV32
+typedef struct StdVideoEncodeAV1ReferenceInfo32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkFormat vertexFormat;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData;
-    VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
-    VkFormat radiusFormat;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) radiusData;
-    VkDeviceSize DECLSPEC_ALIGN(8) radiusStride;
-    VkIndexType indexType;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData;
-    VkDeviceSize DECLSPEC_ALIGN(8) indexStride;
-    VkRayTracingLssIndexingModeNV indexingMode;
-    VkRayTracingLssPrimitiveEndCapsModeNV endCapsMode;
-} VkAccelerationStructureGeometryLinearSweptSpheresDataNV32;
+    StdVideoEncodeAV1ReferenceInfoFlags flags;
+    uint32_t RefFrameId;
+    StdVideoAV1FrameType frame_type;
+    uint8_t OrderHint;
+    uint8_t reserved1[3];
+    PTR32 pExtensionHeader;
+} StdVideoEncodeAV1ReferenceInfo32;

-typedef struct VkAccelerationStructureGeometrySpheresDataNV32
+typedef struct StdVideoEncodeH264PictureInfo32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkFormat vertexFormat;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData;
-    VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
-    VkFormat radiusFormat;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) radiusData;
-    VkDeviceSize DECLSPEC_ALIGN(8) radiusStride;
-    VkIndexType indexType;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData;
-    VkDeviceSize DECLSPEC_ALIGN(8) indexStride;
-} VkAccelerationStructureGeometrySpheresDataNV32;
+    StdVideoEncodeH264PictureInfoFlags flags;
+    uint8_t seq_parameter_set_id;
+    uint8_t pic_parameter_set_id;
+    uint16_t idr_pic_id;
+    StdVideoH264PictureType primary_pic_type;
+    uint32_t frame_num;
+    int32_t PicOrderCnt;
+    uint8_t temporal_id;
+    uint8_t reserved1[3];
+    PTR32 pRefLists;
+} StdVideoEncodeH264PictureInfo32;

typedef struct VkAccelerationStructureGeometryKHR32
 {
@@ -501,70 +710,51 @@ typedef struct VkAccelerationStructureGeometryKHR32
     VkGeometryFlagsKHR flags;
 } VkAccelerationStructureGeometryKHR32;

-typedef struct VkAccelerationStructureBuildGeometryInfoKHR32
+typedef struct VkAccelerationStructureInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAccelerationStructureTypeKHR type;
-    VkBuildAccelerationStructureFlagsKHR flags;
-    VkBuildAccelerationStructureModeKHR mode;
-    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) srcAccelerationStructure;
-    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dstAccelerationStructure;
+    VkAccelerationStructureTypeNV type;
+    VkBuildAccelerationStructureFlagsNV flags;
+    uint32_t instanceCount;
     uint32_t geometryCount;
     PTR32 pGeometries;
-    PTR32 ppGeometries;
-    VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
-} VkAccelerationStructureBuildGeometryInfoKHR32;
-
-typedef struct VkMicromapBuildInfoEXT32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkMicromapTypeEXT type;
-    VkBuildMicromapFlagsEXT flags;
-    VkBuildMicromapModeEXT mode;
-    VkMicromapEXT DECLSPEC_ALIGN(8) dstMicromap;
-    uint32_t usageCountsCount;
-    PTR32 pUsageCounts;
-    PTR32 ppUsageCounts;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
-    VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) triangleArray;
-    VkDeviceSize DECLSPEC_ALIGN(8) triangleArrayStride;
-} VkMicromapBuildInfoEXT32;
-
-typedef struct VkConditionalRenderingBeginInfoEXT32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-    VkDeviceSize DECLSPEC_ALIGN(8) offset;
-    VkConditionalRenderingFlagsEXT flags;
-} VkConditionalRenderingBeginInfoEXT32;
+} VkAccelerationStructureInfoNV32;

-typedef struct VkDebugUtilsLabelEXT32
+typedef struct VkAntiLagPresentationInfoAMD32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pLabelName;
-    float color[4];
-} VkDebugUtilsLabelEXT32;
+    VkAntiLagStageAMD stage;
+    uint64_t DECLSPEC_ALIGN(8) frameIndex;
+} VkAntiLagPresentationInfoAMD32;

-typedef struct VkPerTileBeginInfoQCOM32
+typedef struct VkApplicationInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-} VkPerTileBeginInfoQCOM32;
+    PTR32 pApplicationName;
+    uint32_t applicationVersion;
+    PTR32 pEngineName;
+    uint32_t engineVersion;
+    uint32_t apiVersion;
+} VkApplicationInfo32;

-typedef struct VkSampleLocationsInfoEXT32
+typedef struct VkAttachmentDescription232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSampleCountFlagBits sampleLocationsPerPixel;
-    VkExtent2D sampleLocationGridSize;
-    uint32_t sampleLocationsCount;
-    PTR32 pSampleLocations;
-} VkSampleLocationsInfoEXT32;
+    VkAttachmentDescriptionFlags flags;
+    VkFormat format;
+    VkSampleCountFlagBits samples;
+    VkAttachmentLoadOp loadOp;
+    VkAttachmentStoreOp storeOp;
+    VkAttachmentLoadOp stencilLoadOp;
+    VkAttachmentStoreOp stencilStoreOp;
+    VkImageLayout initialLayout;
+    VkImageLayout finalLayout;
+} VkAttachmentDescription232;
+typedef VkAttachmentDescription232 VkAttachmentDescription2KHR32;

typedef struct VkAttachmentSampleLocationsEXT32
 {
@@ -572,518 +762,676 @@ typedef struct VkAttachmentSampleLocationsEXT32
     VkSampleLocationsInfoEXT32 sampleLocationsInfo;
 } VkAttachmentSampleLocationsEXT32;

-typedef struct VkSubpassSampleLocationsEXT32
+typedef struct VkBufferCopy232
 {
-    uint32_t subpassIndex;
-    VkSampleLocationsInfoEXT32 sampleLocationsInfo;
-} VkSubpassSampleLocationsEXT32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
+    VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+} VkBufferCopy232;
+typedef VkBufferCopy232 VkBufferCopy2KHR32;

-typedef struct VkRenderPassStripeInfoARM32
+typedef struct VkBufferCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkRect2D stripeArea;
-} VkRenderPassStripeInfoARM32;
+    VkBufferCreateFlags flags;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+    VkBufferUsageFlags usage;
+    VkSharingMode sharingMode;
+    uint32_t queueFamilyIndexCount;
+    PTR32 pQueueFamilyIndices;
+} VkBufferCreateInfo32;

-typedef struct VkDeviceGroupRenderPassBeginInfo32
+typedef struct VkBufferImageCopy232
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t deviceMask;
-    uint32_t deviceRenderAreaCount;
-    PTR32 pDeviceRenderAreas;
-} VkDeviceGroupRenderPassBeginInfo32;
-typedef VkDeviceGroupRenderPassBeginInfo32 VkDeviceGroupRenderPassBeginInfoKHR32;
+    VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
+    uint32_t bufferRowLength;
+    uint32_t bufferImageHeight;
+    VkImageSubresourceLayers imageSubresource;
+    VkOffset3D imageOffset;
+    VkExtent3D imageExtent;
+} VkBufferImageCopy232;
+typedef VkBufferImageCopy232 VkBufferImageCopy2KHR32;

-typedef struct VkRenderPassSampleLocationsBeginInfoEXT32
+typedef struct VkBufferMemoryBarrier232
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t attachmentInitialSampleLocationsCount;
-    PTR32 pAttachmentInitialSampleLocations;
-    uint32_t postSubpassSampleLocationsCount;
-    PTR32 pPostSubpassSampleLocations;
-} VkRenderPassSampleLocationsBeginInfoEXT32;
+    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
+    VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
+    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
+    VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+    VkDeviceSize DECLSPEC_ALIGN(8) offset;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+} VkBufferMemoryBarrier232;
+typedef VkBufferMemoryBarrier232 VkBufferMemoryBarrier2KHR32;

-typedef struct VkRenderPassAttachmentBeginInfo32
+typedef struct VkClusterAccelerationStructureInputInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t attachmentCount;
-    PTR32 pAttachments;
-} VkRenderPassAttachmentBeginInfo32;
-typedef VkRenderPassAttachmentBeginInfo32 VkRenderPassAttachmentBeginInfoKHR32;
+    uint32_t maxAccelerationStructureCount;
+    VkBuildAccelerationStructureFlagsKHR flags;
+    VkClusterAccelerationStructureOpTypeNV opType;
+    VkClusterAccelerationStructureOpModeNV opMode;
+    VkClusterAccelerationStructureOpInputNV32 opInput;
+} VkClusterAccelerationStructureInputInfoNV32;

-typedef struct VkRenderPassTransformBeginInfoQCOM32
+typedef struct VkCoarseSampleOrderCustomNV32
+{
+    VkShadingRatePaletteEntryNV shadingRate;
+    uint32_t sampleCount;
+    uint32_t sampleLocationCount;
+    PTR32 pSampleLocations;
+} VkCoarseSampleOrderCustomNV32;
+
+typedef struct VkCommandBufferInheritanceInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSurfaceTransformFlagBitsKHR transform;
-} VkRenderPassTransformBeginInfoQCOM32;
+    VkRenderPass DECLSPEC_ALIGN(8) renderPass;
+    uint32_t subpass;
+    VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
+    VkBool32 occlusionQueryEnable;
+    VkQueryControlFlags queryFlags;
+    VkQueryPipelineStatisticFlags pipelineStatistics;
+} VkCommandBufferInheritanceInfo32;

-typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32
+typedef struct VkCommandBufferSubmitInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t perViewRenderAreaCount;
-    PTR32 pPerViewRenderAreas;
-} VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32;
+    PTR32 commandBuffer;
+    uint32_t deviceMask;
+} VkCommandBufferSubmitInfo32;
+typedef VkCommandBufferSubmitInfo32 VkCommandBufferSubmitInfoKHR32;

-typedef struct VkRenderPassStripeBeginInfoARM32
+typedef struct VkDataGraphPipelineConstantARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t stripeInfoCount;
-    PTR32 pStripeInfos;
-} VkRenderPassStripeBeginInfoARM32;
+    uint32_t id;
+    PTR32 pConstantData;
+} VkDataGraphPipelineConstantARM32;

-typedef struct VkRenderPassBeginInfo32
+typedef struct VkDataGraphPipelineResourceInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkRenderPass DECLSPEC_ALIGN(8) renderPass;
-    VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
-    VkRect2D renderArea;
-    uint32_t clearValueCount;
-    PTR32 pClearValues;
-} VkRenderPassBeginInfo32;
+    uint32_t descriptorSet;
+    uint32_t binding;
+    uint32_t arrayElement;
+} VkDataGraphPipelineResourceInfoARM32;

-typedef struct VkSubpassBeginInfo32
+typedef struct VkDebugUtilsLabelEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSubpassContents contents;
-} VkSubpassBeginInfo32;
-typedef VkSubpassBeginInfo32 VkSubpassBeginInfoKHR32;
+    PTR32 pLabelName;
+    float color[4];
+} VkDebugUtilsLabelEXT32;

-typedef struct VkAttachmentFeedbackLoopInfoEXT32
+typedef struct VkDebugUtilsObjectNameInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 feedbackLoopEnable;
-} VkAttachmentFeedbackLoopInfoEXT32;
+    VkObjectType objectType;
+    uint64_t DECLSPEC_ALIGN(8) objectHandle;
+    PTR32 pObjectName;
+} VkDebugUtilsObjectNameInfoEXT32;

-typedef struct VkRenderingAttachmentInfo32
+typedef union VkDescriptorDataEXT32
+{
+    PTR32 pSampler;
+    PTR32 pCombinedImageSampler;
+    PTR32 pInputAttachmentImage;
+    PTR32 pSampledImage;
+    PTR32 pStorageImage;
+    PTR32 pUniformTexelBuffer;
+    PTR32 pStorageTexelBuffer;
+    PTR32 pUniformBuffer;
+    PTR32 pStorageBuffer;
+    VkDeviceAddress DECLSPEC_ALIGN(8) accelerationStructure;
+} VkDescriptorDataEXT32;
+
+typedef struct VkDescriptorSetLayoutBinding32
+{
+    uint32_t binding;
+    VkDescriptorType descriptorType;
+    uint32_t descriptorCount;
+    VkShaderStageFlags stageFlags;
+    PTR32 pImmutableSamplers;
+} VkDescriptorSetLayoutBinding32;
+
+typedef struct VkDescriptorUpdateTemplateEntry32
+{
+    uint32_t dstBinding;
+    uint32_t dstArrayElement;
+    uint32_t descriptorCount;
+    VkDescriptorType descriptorType;
+    PTR32 offset;
+    PTR32 stride;
+} VkDescriptorUpdateTemplateEntry32;
+typedef VkDescriptorUpdateTemplateEntry32 VkDescriptorUpdateTemplateEntryKHR32;
+
+typedef struct VkDeviceFaultAddressInfoEXT32
+{
+    VkDeviceFaultAddressTypeEXT addressType;
+    VkDeviceAddress DECLSPEC_ALIGN(8) reportedAddress;
+    VkDeviceSize DECLSPEC_ALIGN(8) addressPrecision;
+} VkDeviceFaultAddressInfoEXT32;
+
+typedef struct VkDeviceFaultVendorInfoEXT32
+{
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    uint64_t DECLSPEC_ALIGN(8) vendorFaultCode;
+    uint64_t DECLSPEC_ALIGN(8) vendorFaultData;
+} VkDeviceFaultVendorInfoEXT32;
+
+typedef struct VkDeviceQueueCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageView DECLSPEC_ALIGN(8) imageView;
-    VkImageLayout imageLayout;
-    VkResolveModeFlagBits resolveMode;
-    VkImageView DECLSPEC_ALIGN(8) resolveImageView;
-    VkImageLayout resolveImageLayout;
-    VkAttachmentLoadOp loadOp;
-    VkAttachmentStoreOp storeOp;
-    VkClearValue clearValue;
-} VkRenderingAttachmentInfo32;
-typedef VkRenderingAttachmentInfo32 VkRenderingAttachmentInfoKHR32;
+    VkDeviceQueueCreateFlags flags;
+    uint32_t queueFamilyIndex;
+    uint32_t queueCount;
+    PTR32 pQueuePriorities;
+} VkDeviceQueueCreateInfo32;
+
+typedef struct VkFramebufferAttachmentImageInfo32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkImageCreateFlags flags;
+    VkImageUsageFlags usage;
+    uint32_t width;
+    uint32_t height;
+    uint32_t layerCount;
+    uint32_t viewFormatCount;
+    PTR32 pViewFormats;
+} VkFramebufferAttachmentImageInfo32;
+typedef VkFramebufferAttachmentImageInfo32 VkFramebufferAttachmentImageInfoKHR32;
+
+typedef struct VkGraphicsShaderGroupCreateInfoNV32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t stageCount;
+    PTR32 pStages;
+    PTR32 pVertexInputState;
+    PTR32 pTessellationState;
+} VkGraphicsShaderGroupCreateInfoNV32;

-typedef struct VkMultisampledRenderToSingleSampledInfoEXT32
+typedef struct VkImageBlit232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 multisampledRenderToSingleSampledEnable;
-    VkSampleCountFlagBits rasterizationSamples;
-} VkMultisampledRenderToSingleSampledInfoEXT32;
+    VkImageSubresourceLayers srcSubresource;
+    VkOffset3D srcOffsets[2];
+    VkImageSubresourceLayers dstSubresource;
+    VkOffset3D dstOffsets[2];
+} VkImageBlit232;
+typedef VkImageBlit232 VkImageBlit2KHR32;

-typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR32
+typedef struct VkImageCopy232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageView DECLSPEC_ALIGN(8) imageView;
-    VkImageLayout imageLayout;
-    VkExtent2D shadingRateAttachmentTexelSize;
-} VkRenderingFragmentShadingRateAttachmentInfoKHR32;
+    VkImageSubresourceLayers srcSubresource;
+    VkOffset3D srcOffset;
+    VkImageSubresourceLayers dstSubresource;
+    VkOffset3D dstOffset;
+    VkExtent3D extent;
+} VkImageCopy232;
+typedef VkImageCopy232 VkImageCopy2KHR32;

-typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT32
+typedef struct VkImageFormatProperties32
+{
+    VkExtent3D maxExtent;
+    uint32_t maxMipLevels;
+    uint32_t maxArrayLayers;
+    VkSampleCountFlags sampleCounts;
+    VkDeviceSize DECLSPEC_ALIGN(8) maxResourceSize;
+} VkImageFormatProperties32;
+
+typedef struct VkImageMemoryBarrier232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageView DECLSPEC_ALIGN(8) imageView;
-    VkImageLayout imageLayout;
-} VkRenderingFragmentDensityMapAttachmentInfoEXT32;
+    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
+    VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
+    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
+    VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
+    VkImageLayout oldLayout;
+    VkImageLayout newLayout;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    VkImage DECLSPEC_ALIGN(8) image;
+    VkImageSubresourceRange subresourceRange;
+} VkImageMemoryBarrier232;
+typedef VkImageMemoryBarrier232 VkImageMemoryBarrier2KHR32;

-typedef struct VkTileMemorySizeInfoQCOM32
+typedef struct VkImageResolve232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-} VkTileMemorySizeInfoQCOM32;
+    VkImageSubresourceLayers srcSubresource;
+    VkOffset3D srcOffset;
+    VkImageSubresourceLayers dstSubresource;
+    VkOffset3D dstOffset;
+    VkExtent3D extent;
+} VkImageResolve232;
+typedef VkImageResolve232 VkImageResolve2KHR32;

-typedef struct VkRenderingInfo32
+typedef struct VkImageSubresource232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkRenderingFlags flags;
-    VkRect2D renderArea;
-    uint32_t layerCount;
-    uint32_t viewMask;
-    uint32_t colorAttachmentCount;
-    PTR32 pColorAttachments;
-    PTR32 pDepthAttachment;
-    PTR32 pStencilAttachment;
-} VkRenderingInfo32;
-typedef VkRenderingInfo32 VkRenderingInfoKHR32;
+    VkImageSubresource imageSubresource;
+} VkImageSubresource232;
+typedef VkImageSubresource232 VkImageSubresource2KHR32;
+typedef VkImageSubresource232 VkImageSubresource2EXT32;

-typedef struct VkVideoEncodeH264RateControlLayerInfoKHR32
+typedef struct VkImageToMemoryCopy32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 useMinQp;
-    VkVideoEncodeH264QpKHR minQp;
-    VkBool32 useMaxQp;
-    VkVideoEncodeH264QpKHR maxQp;
-    VkBool32 useMaxFrameSize;
-    VkVideoEncodeH264FrameSizeKHR maxFrameSize;
-} VkVideoEncodeH264RateControlLayerInfoKHR32;
+    PTR32 pHostPointer;
+    uint32_t memoryRowLength;
+    uint32_t memoryImageHeight;
+    VkImageSubresourceLayers imageSubresource;
+    VkOffset3D imageOffset;
+    VkExtent3D imageExtent;
+} VkImageToMemoryCopy32;
+typedef VkImageToMemoryCopy32 VkImageToMemoryCopyEXT32;

-typedef struct VkVideoEncodeAV1RateControlLayerInfoKHR32
+typedef struct VkIndirectCommandsLayoutTokenEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 useMinQIndex;
-    VkVideoEncodeAV1QIndexKHR minQIndex;
-    VkBool32 useMaxQIndex;
-    VkVideoEncodeAV1QIndexKHR maxQIndex;
-    VkBool32 useMaxFrameSize;
-    VkVideoEncodeAV1FrameSizeKHR maxFrameSize;
-} VkVideoEncodeAV1RateControlLayerInfoKHR32;
+    VkIndirectCommandsTokenTypeEXT type;
+    VkIndirectCommandsTokenDataEXT32 data;
+    uint32_t offset;
+} VkIndirectCommandsLayoutTokenEXT32;

-typedef struct VkVideoEncodeRateControlLayerInfoKHR32
+typedef struct VkIndirectCommandsLayoutTokenNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint64_t DECLSPEC_ALIGN(8) averageBitrate;
-    uint64_t DECLSPEC_ALIGN(8) maxBitrate;
-    uint32_t frameRateNumerator;
-    uint32_t frameRateDenominator;
-} VkVideoEncodeRateControlLayerInfoKHR32;
+    VkIndirectCommandsTokenTypeNV tokenType;
+    uint32_t stream;
+    uint32_t offset;
+    uint32_t vertexBindingUnit;
+    VkBool32 vertexDynamicStride;
+    VkPipelineLayout DECLSPEC_ALIGN(8) pushconstantPipelineLayout;
+    VkShaderStageFlags pushconstantShaderStageFlags;
+    uint32_t pushconstantOffset;
+    uint32_t pushconstantSize;
+    VkIndirectStateFlagsNV indirectStateFlags;
+    uint32_t indexTypeCount;
+    PTR32 pIndexTypes;
+    PTR32 pIndexTypeValues;
+} VkIndirectCommandsLayoutTokenNV32;

-typedef struct StdVideoEncodeAV1ReferenceInfo32
+typedef struct VkIndirectCommandsStreamNV32
 {
-    StdVideoEncodeAV1ReferenceInfoFlags flags;
-    uint32_t RefFrameId;
-    StdVideoAV1FrameType frame_type;
-    uint8_t OrderHint;
-    uint8_t reserved1[3];
-    PTR32 pExtensionHeader;
-} StdVideoEncodeAV1ReferenceInfo32;
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+    VkDeviceSize DECLSPEC_ALIGN(8) offset;
+} VkIndirectCommandsStreamNV32;

-typedef struct VkVideoPictureResourceInfoKHR32
+typedef union VkIndirectExecutionSetInfoEXT32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkOffset2D codedOffset;
-    VkExtent2D codedExtent;
-    uint32_t baseArrayLayer;
-    VkImageView DECLSPEC_ALIGN(8) imageViewBinding;
-} VkVideoPictureResourceInfoKHR32;
+    PTR32 pPipelineInfo;
+    PTR32 pShaderInfo;
+} VkIndirectExecutionSetInfoEXT32;

-typedef struct VkVideoDecodeH264DpbSlotInfoKHR32
+typedef struct VkLatencyTimingsFrameReportNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pStdReferenceInfo;
-} VkVideoDecodeH264DpbSlotInfoKHR32;
+    uint64_t DECLSPEC_ALIGN(8) presentID;
+    uint64_t DECLSPEC_ALIGN(8) inputSampleTimeUs;
+    uint64_t DECLSPEC_ALIGN(8) simStartTimeUs;
+    uint64_t DECLSPEC_ALIGN(8) simEndTimeUs;
+    uint64_t DECLSPEC_ALIGN(8) renderSubmitStartTimeUs;
+    uint64_t DECLSPEC_ALIGN(8) renderSubmitEndTimeUs;
+    uint64_t DECLSPEC_ALIGN(8) presentStartTimeUs;
+    uint64_t DECLSPEC_ALIGN(8) presentEndTimeUs;
+    uint64_t DECLSPEC_ALIGN(8) driverStartTimeUs;
+    uint64_t DECLSPEC_ALIGN(8) driverEndTimeUs;
+    uint64_t DECLSPEC_ALIGN(8) osRenderQueueStartTimeUs;
+    uint64_t DECLSPEC_ALIGN(8) osRenderQueueEndTimeUs;
+    uint64_t DECLSPEC_ALIGN(8) gpuRenderStartTimeUs;
+    uint64_t DECLSPEC_ALIGN(8) gpuRenderEndTimeUs;
+} VkLatencyTimingsFrameReportNV32;

-typedef struct VkVideoDecodeAV1DpbSlotInfoKHR32
+typedef struct VkLayerSettingEXT32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    PTR32 pStdReferenceInfo;
-} VkVideoDecodeAV1DpbSlotInfoKHR32;
+    PTR32 pLayerName;
+    PTR32 pSettingName;
+    VkLayerSettingTypeEXT type;
+    uint32_t valueCount;
+    PTR32 pValues;
+} VkLayerSettingEXT32;

-typedef struct VkVideoEncodeH264DpbSlotInfoKHR32
+typedef struct VkMemoryBarrier232
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pStdReferenceInfo;
-} VkVideoEncodeH264DpbSlotInfoKHR32;
+    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
+    VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
+    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
+    VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
+} VkMemoryBarrier232;
+typedef VkMemoryBarrier232 VkMemoryBarrier2KHR32;

-typedef struct VkVideoEncodeAV1DpbSlotInfoKHR32
+typedef struct VkMemoryRequirements32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    PTR32 pStdReferenceInfo;
-} VkVideoEncodeAV1DpbSlotInfoKHR32;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+    VkDeviceSize DECLSPEC_ALIGN(8) alignment;
+    uint32_t memoryTypeBits;
+} VkMemoryRequirements32;

-typedef struct VkVideoReferenceIntraRefreshInfoKHR32
+typedef struct VkMemoryToImageCopy32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t dirtyIntraRefreshRegions;
-} VkVideoReferenceIntraRefreshInfoKHR32;
+    PTR32 pHostPointer;
+    uint32_t memoryRowLength;
+    uint32_t memoryImageHeight;
+    VkImageSubresourceLayers imageSubresource;
+    VkOffset3D imageOffset;
+    VkExtent3D imageExtent;
+} VkMemoryToImageCopy32;
+typedef VkMemoryToImageCopy32 VkMemoryToImageCopyEXT32;

-typedef struct VkVideoReferenceSlotInfoKHR32
+typedef struct VkMutableDescriptorTypeListEXT32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    int32_t slotIndex;
-    PTR32 pPictureResource;
-} VkVideoReferenceSlotInfoKHR32;
+    uint32_t descriptorTypeCount;
+    PTR32 pDescriptorTypes;
+} VkMutableDescriptorTypeListEXT32;
+typedef VkMutableDescriptorTypeListEXT32 VkMutableDescriptorTypeListVALVE32;

-typedef struct VkVideoEncodeRateControlInfoKHR32
+typedef struct VkPartitionedAccelerationStructureInstancesInputNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeRateControlFlagsKHR flags;
-    VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode;
-    uint32_t layerCount;
-    PTR32 pLayers;
-    uint32_t virtualBufferSizeInMs;
-    uint32_t initialVirtualBufferSizeInMs;
-} VkVideoEncodeRateControlInfoKHR32;
+    VkBuildAccelerationStructureFlagsKHR flags;
+    uint32_t instanceCount;
+    uint32_t maxInstancePerPartitionCount;
+    uint32_t partitionCount;
+    uint32_t maxInstanceInGlobalPartitionCount;
+} VkPartitionedAccelerationStructureInstancesInputNV32;
+
+typedef union VkPerformanceValueDataINTEL32
+{
+    uint32_t value32;
+    uint64_t DECLSPEC_ALIGN(8) value64;
+    float valueFloat;
+    VkBool32 valueBool;
+    PTR32 valueString;
+} VkPerformanceValueDataINTEL32;
+
+typedef struct VkPhysicalDeviceMemoryProperties32
+{
+    uint32_t memoryTypeCount;
+    VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
+    uint32_t memoryHeapCount;
+    VkMemoryHeap32 DECLSPEC_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS];
+} VkPhysicalDeviceMemoryProperties32;

-typedef struct VkVideoEncodeH264RateControlInfoKHR32
+typedef struct VkPhysicalDeviceProperties232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeH264RateControlFlagsKHR flags;
-    uint32_t gopFrameCount;
-    uint32_t idrPeriod;
-    uint32_t consecutiveBFrameCount;
-    uint32_t temporalLayerCount;
-} VkVideoEncodeH264RateControlInfoKHR32;
+    VkPhysicalDeviceProperties32 DECLSPEC_ALIGN(8) properties;
+} VkPhysicalDeviceProperties232;
+typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32;

-typedef struct VkVideoEncodeH264GopRemainingFrameInfoKHR32
+typedef struct VkPipelineBinaryKeysAndDataKHR32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkBool32 useGopRemainingFrames;
-    uint32_t gopRemainingI;
-    uint32_t gopRemainingP;
-    uint32_t gopRemainingB;
-} VkVideoEncodeH264GopRemainingFrameInfoKHR32;
+    uint32_t binaryCount;
+    PTR32 pPipelineBinaryKeys;
+    PTR32 pPipelineBinaryData;
+} VkPipelineBinaryKeysAndDataKHR32;

-typedef struct VkVideoEncodeAV1RateControlInfoKHR32
+typedef struct VkPipelineCacheCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeAV1RateControlFlagsKHR flags;
-    uint32_t gopFrameCount;
-    uint32_t keyFramePeriod;
-    uint32_t consecutiveBipredictiveFrameCount;
-    uint32_t temporalLayerCount;
-} VkVideoEncodeAV1RateControlInfoKHR32;
+    VkPipelineCacheCreateFlags flags;
+    PTR32 initialDataSize;
+    PTR32 pInitialData;
+} VkPipelineCacheCreateInfo32;

-typedef struct VkVideoEncodeAV1GopRemainingFrameInfoKHR32
+typedef struct VkPipelineColorBlendStateCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 useGopRemainingFrames;
-    uint32_t gopRemainingIntra;
-    uint32_t gopRemainingPredictive;
-    uint32_t gopRemainingBipredictive;
-} VkVideoEncodeAV1GopRemainingFrameInfoKHR32;
+    VkPipelineColorBlendStateCreateFlags flags;
+    VkBool32 logicOpEnable;
+    VkLogicOp logicOp;
+    uint32_t attachmentCount;
+    PTR32 pAttachments;
+    float blendConstants[4];
+} VkPipelineColorBlendStateCreateInfo32;

-typedef struct VkVideoBeginCodingInfoKHR32
+typedef struct VkPipelineCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoBeginCodingFlagsKHR flags;
-    VkVideoSessionKHR DECLSPEC_ALIGN(8) videoSession;
-    VkVideoSessionParametersKHR DECLSPEC_ALIGN(8) videoSessionParameters;
-    uint32_t referenceSlotCount;
-    PTR32 pReferenceSlots;
-} VkVideoBeginCodingInfoKHR32;
+} VkPipelineCreateInfoKHR32;

-typedef struct VkPipelineLayoutCreateInfo32
+typedef struct VkPipelineCreationFeedback32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkPipelineLayoutCreateFlags flags;
-    uint32_t setLayoutCount;
-    PTR32 pSetLayouts;
-    uint32_t pushConstantRangeCount;
-    PTR32 pPushConstantRanges;
-} VkPipelineLayoutCreateInfo32;
+    VkPipelineCreationFeedbackFlags flags;
+    uint64_t DECLSPEC_ALIGN(8) duration;
+} VkPipelineCreationFeedback32;
+typedef VkPipelineCreationFeedback32 VkPipelineCreationFeedbackEXT32;

-typedef struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT32
+typedef struct VkPipelineDepthStencilStateCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderStageFlags stageFlags;
-    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
-    uint32_t set;
-} VkBindDescriptorBufferEmbeddedSamplersInfoEXT32;
+    VkPipelineDepthStencilStateCreateFlags flags;
+    VkBool32 depthTestEnable;
+    VkBool32 depthWriteEnable;
+    VkCompareOp depthCompareOp;
+    VkBool32 depthBoundsTestEnable;
+    VkBool32 stencilTestEnable;
+    VkStencilOpState front;
+    VkStencilOpState back;
+    float minDepthBounds;
+    float maxDepthBounds;
+} VkPipelineDepthStencilStateCreateInfo32;

-typedef struct VkBufferUsageFlags2CreateInfo32
+typedef struct VkPipelineDynamicStateCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBufferUsageFlags2 DECLSPEC_ALIGN(8) usage;
-} VkBufferUsageFlags2CreateInfo32;
-typedef VkBufferUsageFlags2CreateInfo32 VkBufferUsageFlags2CreateInfoKHR32;
+    VkPipelineDynamicStateCreateFlags flags;
+    uint32_t dynamicStateCount;
+    PTR32 pDynamicStates;
+} VkPipelineDynamicStateCreateInfo32;

-typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32
+typedef union VkPipelineExecutableStatisticValueKHR32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-} VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32;
+    VkBool32 b32;
+    int64_t i64;
+    uint64_t DECLSPEC_ALIGN(8) u64;
+    double f64;
+} VkPipelineExecutableStatisticValueKHR32;

-typedef struct VkDescriptorBufferBindingInfoEXT32
+typedef struct VkPipelineInputAssemblyStateCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceAddress DECLSPEC_ALIGN(8) address;
-    VkBufferUsageFlags usage;
-} VkDescriptorBufferBindingInfoEXT32;
+    VkPipelineInputAssemblyStateCreateFlags flags;
+    VkPrimitiveTopology topology;
+    VkBool32 primitiveRestartEnable;
+} VkPipelineInputAssemblyStateCreateInfo32;

-typedef struct VkBindDescriptorSetsInfo32
+typedef struct VkPipelineLibraryCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderStageFlags stageFlags;
-    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
-    uint32_t firstSet;
-    uint32_t descriptorSetCount;
-    PTR32 pDescriptorSets;
-    uint32_t dynamicOffsetCount;
-    PTR32 pDynamicOffsets;
-} VkBindDescriptorSetsInfo32;
-typedef VkBindDescriptorSetsInfo32 VkBindDescriptorSetsInfoKHR32;
+    uint32_t libraryCount;
+    PTR32 pLibraries;
+} VkPipelineLibraryCreateInfoKHR32;

-typedef struct VkCopyCommandTransformInfoQCOM32
+typedef struct VkPipelineMultisampleStateCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSurfaceTransformFlagBitsKHR transform;
-} VkCopyCommandTransformInfoQCOM32;
+    VkPipelineMultisampleStateCreateFlags flags;
+    VkSampleCountFlagBits rasterizationSamples;
+    VkBool32 sampleShadingEnable;
+    float minSampleShading;
+    PTR32 pSampleMask;
+    VkBool32 alphaToCoverageEnable;
+    VkBool32 alphaToOneEnable;
+} VkPipelineMultisampleStateCreateInfo32;

-typedef struct VkImageBlit232
+typedef struct VkPipelineRasterizationStateCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageSubresourceLayers srcSubresource;
-    VkOffset3D srcOffsets[2];
-    VkImageSubresourceLayers dstSubresource;
-    VkOffset3D dstOffsets[2];
-} VkImageBlit232;
-typedef VkImageBlit232 VkImageBlit2KHR32;
+    VkPipelineRasterizationStateCreateFlags flags;
+    VkBool32 depthClampEnable;
+    VkBool32 rasterizerDiscardEnable;
+    VkPolygonMode polygonMode;
+    VkCullModeFlags cullMode;
+    VkFrontFace frontFace;
+    VkBool32 depthBiasEnable;
+    float depthBiasConstantFactor;
+    float depthBiasClamp;
+    float depthBiasSlopeFactor;
+    float lineWidth;
+} VkPipelineRasterizationStateCreateInfo32;

-typedef struct VkBlitImageCubicWeightsInfoQCOM32
+typedef struct VkPipelineViewportStateCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkCubicFilterWeightsQCOM cubicWeights;
-} VkBlitImageCubicWeightsInfoQCOM32;
+    VkPipelineViewportStateCreateFlags flags;
+    uint32_t viewportCount;
+    PTR32 pViewports;
+    uint32_t scissorCount;
+    PTR32 pScissors;
+} VkPipelineViewportStateCreateInfo32;

-typedef struct VkBlitImageInfo232
+typedef struct VkPresentRegionKHR32
+{
+    uint32_t rectangleCount;
+    PTR32 pRectangles;
+} VkPresentRegionKHR32;
+
+typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImage DECLSPEC_ALIGN(8) srcImage;
-    VkImageLayout srcImageLayout;
-    VkImage DECLSPEC_ALIGN(8) dstImage;
-    VkImageLayout dstImageLayout;
-    uint32_t regionCount;
-    PTR32 pRegions;
-    VkFilter filter;
-} VkBlitImageInfo232;
-typedef VkBlitImageInfo232 VkBlitImageInfo2KHR32;
+    uint32_t maxPipelineRayPayloadSize;
+    uint32_t maxPipelineRayHitAttributeSize;
+} VkRayTracingPipelineInterfaceCreateInfoKHR32;

-typedef struct VkGeometryTrianglesNV32
+typedef struct VkRayTracingShaderGroupCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBuffer DECLSPEC_ALIGN(8) vertexData;
-    VkDeviceSize DECLSPEC_ALIGN(8) vertexOffset;
-    uint32_t vertexCount;
-    VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
-    VkFormat vertexFormat;
-    VkBuffer DECLSPEC_ALIGN(8) indexData;
-    VkDeviceSize DECLSPEC_ALIGN(8) indexOffset;
-    uint32_t indexCount;
-    VkIndexType indexType;
-    VkBuffer DECLSPEC_ALIGN(8) transformData;
-    VkDeviceSize DECLSPEC_ALIGN(8) transformOffset;
-} VkGeometryTrianglesNV32;
+    VkRayTracingShaderGroupTypeKHR type;
+    uint32_t generalShader;
+    uint32_t closestHitShader;
+    uint32_t anyHitShader;
+    uint32_t intersectionShader;
+    PTR32 pShaderGroupCaptureReplayHandle;
+} VkRayTracingShaderGroupCreateInfoKHR32;

-typedef struct VkGeometryAABBNV32
+typedef struct VkRayTracingShaderGroupCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBuffer DECLSPEC_ALIGN(8) aabbData;
-    uint32_t numAABBs;
-    uint32_t stride;
-    VkDeviceSize DECLSPEC_ALIGN(8) offset;
-} VkGeometryAABBNV32;
+    VkRayTracingShaderGroupTypeKHR type;
+    uint32_t generalShader;
+    uint32_t closestHitShader;
+    uint32_t anyHitShader;
+    uint32_t intersectionShader;
+} VkRayTracingShaderGroupCreateInfoNV32;

-typedef struct VkGeometryDataNV32
+typedef struct VkRenderPassStripeInfoARM32
 {
-    VkGeometryTrianglesNV32 DECLSPEC_ALIGN(8) triangles;
-    VkGeometryAABBNV32 DECLSPEC_ALIGN(8) aabbs;
-} VkGeometryDataNV32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkRect2D stripeArea;
+} VkRenderPassStripeInfoARM32;

-typedef struct VkGeometryNV32
+typedef struct VkRenderingAttachmentInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkGeometryTypeKHR geometryType;
-    VkGeometryDataNV32 DECLSPEC_ALIGN(8) geometry;
-    VkGeometryFlagsKHR flags;
-} VkGeometryNV32;
+    VkImageView DECLSPEC_ALIGN(8) imageView;
+    VkImageLayout imageLayout;
+    VkResolveModeFlagBits resolveMode;
+    VkImageView DECLSPEC_ALIGN(8) resolveImageView;
+    VkImageLayout resolveImageLayout;
+    VkAttachmentLoadOp loadOp;
+    VkAttachmentStoreOp storeOp;
+    VkClearValue clearValue;
+} VkRenderingAttachmentInfo32;
+typedef VkRenderingAttachmentInfo32 VkRenderingAttachmentInfoKHR32;

-typedef struct VkAccelerationStructureInfoNV32
+typedef struct VkSemaphoreSubmitInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAccelerationStructureTypeNV type;
-    VkBuildAccelerationStructureFlagsNV flags;
-    uint32_t instanceCount;
-    uint32_t geometryCount;
-    PTR32 pGeometries;
-} VkAccelerationStructureInfoNV32;
+    VkSemaphore DECLSPEC_ALIGN(8) semaphore;
+    uint64_t DECLSPEC_ALIGN(8) value;
+    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
+    uint32_t deviceIndex;
+} VkSemaphoreSubmitInfo32;
+typedef VkSemaphoreSubmitInfo32 VkSemaphoreSubmitInfoKHR32;

-typedef struct VkClusterAccelerationStructureClustersBottomLevelInputNV32
+typedef struct VkShadingRatePaletteNV32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    uint32_t maxTotalClusterCount;
-    uint32_t maxClusterCountPerAccelerationStructure;
-} VkClusterAccelerationStructureClustersBottomLevelInputNV32;
+    uint32_t shadingRatePaletteEntryCount;
+    PTR32 pShadingRatePaletteEntries;
+} VkShadingRatePaletteNV32;

-typedef struct VkClusterAccelerationStructureTriangleClusterInputNV32
+typedef struct VkSparseBufferMemoryBindInfo32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkFormat vertexFormat;
-    uint32_t maxGeometryIndexValue;
-    uint32_t maxClusterUniqueGeometryCount;
-    uint32_t maxClusterTriangleCount;
-    uint32_t maxClusterVertexCount;
-    uint32_t maxTotalTriangleCount;
-    uint32_t maxTotalVertexCount;
-    uint32_t minPositionTruncateBitCount;
-} VkClusterAccelerationStructureTriangleClusterInputNV32;
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+    uint32_t bindCount;
+    PTR32 pBinds;
+} VkSparseBufferMemoryBindInfo32;

-typedef struct VkClusterAccelerationStructureMoveObjectsInputNV32
+typedef struct VkSparseImageMemoryBindInfo32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkClusterAccelerationStructureTypeNV type;
-    VkBool32 noMoveOverlap;
-    VkDeviceSize DECLSPEC_ALIGN(8) maxMovedBytes;
-} VkClusterAccelerationStructureMoveObjectsInputNV32;
+    VkImage DECLSPEC_ALIGN(8) image;
+    uint32_t bindCount;
+    PTR32 pBinds;
+} VkSparseImageMemoryBindInfo32;

-typedef union VkClusterAccelerationStructureOpInputNV32
+typedef struct VkSparseImageMemoryRequirements32
 {
-    PTR32 pClustersBottomLevel;
-    PTR32 pTriangleClusters;
-    PTR32 pMoveObjects;
-} VkClusterAccelerationStructureOpInputNV32;
+    VkSparseImageFormatProperties formatProperties;
+    uint32_t imageMipTailFirstLod;
+    VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailSize;
+    VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailOffset;
+    VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailStride;
+} VkSparseImageMemoryRequirements32;

-typedef struct VkClusterAccelerationStructureInputInfoNV32
+typedef struct VkSparseImageOpaqueMemoryBindInfo32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    uint32_t maxAccelerationStructureCount;
-    VkBuildAccelerationStructureFlagsKHR flags;
-    VkClusterAccelerationStructureOpTypeNV opType;
-    VkClusterAccelerationStructureOpModeNV opMode;
-    VkClusterAccelerationStructureOpInputNV32 opInput;
-} VkClusterAccelerationStructureInputInfoNV32;
+    VkImage DECLSPEC_ALIGN(8) image;
+    uint32_t bindCount;
+    PTR32 pBinds;
+} VkSparseImageOpaqueMemoryBindInfo32;

typedef struct VkStridedDeviceAddressRegionKHR32
 {
@@ -1092,674 +1440,573 @@ typedef struct VkStridedDeviceAddressRegionKHR32
     VkDeviceSize DECLSPEC_ALIGN(8) size;
 } VkStridedDeviceAddressRegionKHR32;

-typedef struct VkClusterAccelerationStructureCommandsInfoNV32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkClusterAccelerationStructureInputInfoNV32 input;
-    VkDeviceAddress DECLSPEC_ALIGN(8) dstImplicitData;
-    VkDeviceAddress DECLSPEC_ALIGN(8) scratchData;
-    VkStridedDeviceAddressRegionKHR32 DECLSPEC_ALIGN(8) dstAddressesArray;
-    VkStridedDeviceAddressRegionKHR32 DECLSPEC_ALIGN(8) dstSizesArray;
-    VkStridedDeviceAddressRegionKHR32 DECLSPEC_ALIGN(8) srcInfosArray;
-    VkDeviceAddress DECLSPEC_ALIGN(8) srcInfosCount;
-    VkClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags;
-} VkClusterAccelerationStructureCommandsInfoNV32;
-
-typedef struct VkPartitionedAccelerationStructureFlagsNV32
+typedef struct VkSubpassDependency232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 enablePartitionTranslation;
-} VkPartitionedAccelerationStructureFlagsNV32;
+    uint32_t srcSubpass;
+    uint32_t dstSubpass;
+    VkPipelineStageFlags srcStageMask;
+    VkPipelineStageFlags dstStageMask;
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+    VkDependencyFlags dependencyFlags;
+    int32_t viewOffset;
+} VkSubpassDependency232;
+typedef VkSubpassDependency232 VkSubpassDependency2KHR32;

-typedef struct VkPartitionedAccelerationStructureInstancesInputNV32
+typedef struct VkSubpassDescription32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkBuildAccelerationStructureFlagsKHR flags;
-    uint32_t instanceCount;
-    uint32_t maxInstancePerPartitionCount;
-    uint32_t partitionCount;
-    uint32_t maxInstanceInGlobalPartitionCount;
-} VkPartitionedAccelerationStructureInstancesInputNV32;
+    VkSubpassDescriptionFlags flags;
+    VkPipelineBindPoint pipelineBindPoint;
+    uint32_t inputAttachmentCount;
+    PTR32 pInputAttachments;
+    uint32_t colorAttachmentCount;
+    PTR32 pColorAttachments;
+    PTR32 pResolveAttachments;
+    PTR32 pDepthStencilAttachment;
+    uint32_t preserveAttachmentCount;
+    PTR32 pPreserveAttachments;
+} VkSubpassDescription32;

-typedef struct VkBuildPartitionedAccelerationStructureInfoNV32
+typedef struct VkSubpassDescription232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPartitionedAccelerationStructureInstancesInputNV32 input;
-    VkDeviceAddress DECLSPEC_ALIGN(8) srcAccelerationStructureData;
-    VkDeviceAddress DECLSPEC_ALIGN(8) dstAccelerationStructureData;
-    VkDeviceAddress DECLSPEC_ALIGN(8) scratchData;
-    VkDeviceAddress DECLSPEC_ALIGN(8) srcInfos;
-    VkDeviceAddress DECLSPEC_ALIGN(8) srcInfosCount;
-} VkBuildPartitionedAccelerationStructureInfoNV32;
+    VkSubpassDescriptionFlags flags;
+    VkPipelineBindPoint pipelineBindPoint;
+    uint32_t viewMask;
+    uint32_t inputAttachmentCount;
+    PTR32 pInputAttachments;
+    uint32_t colorAttachmentCount;
+    PTR32 pColorAttachments;
+    PTR32 pResolveAttachments;
+    PTR32 pDepthStencilAttachment;
+    uint32_t preserveAttachmentCount;
+    PTR32 pPreserveAttachments;
+} VkSubpassDescription232;
+typedef VkSubpassDescription232 VkSubpassDescription2KHR32;

-typedef struct VkVideoEncodeQualityLevelInfoKHR32
+typedef struct VkSubpassSampleLocationsEXT32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    uint32_t qualityLevel;
-} VkVideoEncodeQualityLevelInfoKHR32;
+    uint32_t subpassIndex;
+    VkSampleLocationsInfoEXT32 sampleLocationsInfo;
+} VkSubpassSampleLocationsEXT32;

-typedef struct VkVideoCodingControlInfoKHR32
+typedef struct VkSubresourceLayout32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkVideoCodingControlFlagsKHR flags;
-} VkVideoCodingControlInfoKHR32;
+    VkDeviceSize DECLSPEC_ALIGN(8) offset;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+    VkDeviceSize DECLSPEC_ALIGN(8) rowPitch;
+    VkDeviceSize DECLSPEC_ALIGN(8) arrayPitch;
+    VkDeviceSize DECLSPEC_ALIGN(8) depthPitch;
+} VkSubresourceLayout32;

-typedef struct VkConvertCooperativeVectorMatrixInfoNV32
+typedef struct VkTensorCopyARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 srcSize;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) srcData;
-    PTR32 pDstSize;
-    VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dstData;
-    VkComponentTypeKHR srcComponentType;
-    VkComponentTypeKHR dstComponentType;
-    uint32_t numRows;
-    uint32_t numColumns;
-    VkCooperativeVectorMatrixLayoutNV srcLayout;
-    PTR32 srcStride;
-    VkCooperativeVectorMatrixLayoutNV dstLayout;
-    PTR32 dstStride;
-} VkConvertCooperativeVectorMatrixInfoNV32;
+    uint32_t dimensionCount;
+    PTR32 pSrcOffset;
+    PTR32 pDstOffset;
+    PTR32 pExtent;
+} VkTensorCopyARM32;

-typedef struct VkCopyAccelerationStructureInfoKHR32
+typedef struct VkTensorCreateInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
-    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
-    VkCopyAccelerationStructureModeKHR mode;
-} VkCopyAccelerationStructureInfoKHR32;
+    VkTensorCreateFlagsARM DECLSPEC_ALIGN(8) flags;
+    PTR32 pDescription;
+    VkSharingMode sharingMode;
+    uint32_t queueFamilyIndexCount;
+    PTR32 pQueueFamilyIndices;
+} VkTensorCreateInfoARM32;

-typedef struct VkCopyAccelerationStructureToMemoryInfoKHR32
+typedef struct VkTensorMemoryBarrierARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
-    VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
-    VkCopyAccelerationStructureModeKHR mode;
-} VkCopyAccelerationStructureToMemoryInfoKHR32;
-
-typedef struct VkBufferCopy32
-{
-    VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
-    VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-} VkBufferCopy32;
+    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
+    VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
+    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
+    VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    VkTensorARM DECLSPEC_ALIGN(8) tensor;
+} VkTensorMemoryBarrierARM32;

-typedef struct VkBufferCopy232
+typedef struct VkVideoDecodeH264SessionParametersAddInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
-    VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-} VkBufferCopy232;
-typedef VkBufferCopy232 VkBufferCopy2KHR32;
+    uint32_t stdSPSCount;
+    PTR32 pStdSPSs;
+    uint32_t stdPPSCount;
+    PTR32 pStdPPSs;
+} VkVideoDecodeH264SessionParametersAddInfoKHR32;

-typedef struct VkCopyBufferInfo232
+typedef struct VkVideoEncodeH264NaluSliceInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
-    VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
-    uint32_t regionCount;
-    PTR32 pRegions;
-} VkCopyBufferInfo232;
-typedef VkCopyBufferInfo232 VkCopyBufferInfo2KHR32;
-
-typedef struct VkBufferImageCopy32
-{
-    VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
-    uint32_t bufferRowLength;
-    uint32_t bufferImageHeight;
-    VkImageSubresourceLayers imageSubresource;
-    VkOffset3D imageOffset;
-    VkExtent3D imageExtent;
-} VkBufferImageCopy32;
+    int32_t constantQp;
+    PTR32 pStdSliceHeader;
+} VkVideoEncodeH264NaluSliceInfoKHR32;

-typedef struct VkBufferImageCopy232
+typedef struct VkVideoEncodeH264SessionParametersAddInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
-    uint32_t bufferRowLength;
-    uint32_t bufferImageHeight;
-    VkImageSubresourceLayers imageSubresource;
-    VkOffset3D imageOffset;
-    VkExtent3D imageExtent;
-} VkBufferImageCopy232;
-typedef VkBufferImageCopy232 VkBufferImageCopy2KHR32;
+    uint32_t stdSPSCount;
+    PTR32 pStdSPSs;
+    uint32_t stdPPSCount;
+    PTR32 pStdPPSs;
+} VkVideoEncodeH264SessionParametersAddInfoKHR32;

-typedef struct VkCopyBufferToImageInfo232
+typedef struct VkVideoEncodeRateControlLayerInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
-    VkImage DECLSPEC_ALIGN(8) dstImage;
-    VkImageLayout dstImageLayout;
-    uint32_t regionCount;
-    PTR32 pRegions;
-} VkCopyBufferToImageInfo232;
-typedef VkCopyBufferToImageInfo232 VkCopyBufferToImageInfo2KHR32;
+    uint64_t DECLSPEC_ALIGN(8) averageBitrate;
+    uint64_t DECLSPEC_ALIGN(8) maxBitrate;
+    uint32_t frameRateNumerator;
+    uint32_t frameRateDenominator;
+} VkVideoEncodeRateControlLayerInfoKHR32;

-typedef struct VkImageCopy232
+typedef struct VkVideoProfileInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageSubresourceLayers srcSubresource;
-    VkOffset3D srcOffset;
-    VkImageSubresourceLayers dstSubresource;
-    VkOffset3D dstOffset;
-    VkExtent3D extent;
-} VkImageCopy232;
-typedef VkImageCopy232 VkImageCopy2KHR32;
+    VkVideoCodecOperationFlagBitsKHR videoCodecOperation;
+    VkVideoChromaSubsamplingFlagsKHR chromaSubsampling;
+    VkVideoComponentBitDepthFlagsKHR lumaBitDepth;
+    VkVideoComponentBitDepthFlagsKHR chromaBitDepth;
+} VkVideoProfileInfoKHR32;

-typedef struct VkCopyImageInfo232
+typedef struct VkVideoReferenceSlotInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImage DECLSPEC_ALIGN(8) srcImage;
-    VkImageLayout srcImageLayout;
-    VkImage DECLSPEC_ALIGN(8) dstImage;
-    VkImageLayout dstImageLayout;
-    uint32_t regionCount;
-    PTR32 pRegions;
-} VkCopyImageInfo232;
-typedef VkCopyImageInfo232 VkCopyImageInfo2KHR32;
+    int32_t slotIndex;
+    PTR32 pPictureResource;
+} VkVideoReferenceSlotInfoKHR32;

-typedef struct VkCopyImageToBufferInfo232
+typedef struct VkWriteDescriptorSet32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImage DECLSPEC_ALIGN(8) srcImage;
-    VkImageLayout srcImageLayout;
-    VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
-    uint32_t regionCount;
-    PTR32 pRegions;
-} VkCopyImageToBufferInfo232;
-typedef VkCopyImageToBufferInfo232 VkCopyImageToBufferInfo2KHR32;
+    VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
+    uint32_t dstBinding;
+    uint32_t dstArrayElement;
+    uint32_t descriptorCount;
+    VkDescriptorType descriptorType;
+    PTR32 pImageInfo;
+    PTR32 pBufferInfo;
+    PTR32 pTexelBufferView;
+} VkWriteDescriptorSet32;

-typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32
+typedef struct VkAccelerationStructureBuildGeometryInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
-    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
-    VkCopyAccelerationStructureModeKHR mode;
-} VkCopyMemoryToAccelerationStructureInfoKHR32;
+    VkAccelerationStructureTypeKHR type;
+    VkBuildAccelerationStructureFlagsKHR flags;
+    VkBuildAccelerationStructureModeKHR mode;
+    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) srcAccelerationStructure;
+    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dstAccelerationStructure;
+    uint32_t geometryCount;
+    PTR32 pGeometries;
+    PTR32 ppGeometries;
+    VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
+} VkAccelerationStructureBuildGeometryInfoKHR32;

-typedef struct VkCopyMemoryToMicromapInfoEXT32
+typedef struct VkAccelerationStructureBuildSizesInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
-    VkMicromapEXT DECLSPEC_ALIGN(8) dst;
-    VkCopyMicromapModeEXT mode;
-} VkCopyMemoryToMicromapInfoEXT32;
+    VkDeviceSize DECLSPEC_ALIGN(8) accelerationStructureSize;
+    VkDeviceSize DECLSPEC_ALIGN(8) updateScratchSize;
+    VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
+} VkAccelerationStructureBuildSizesInfoKHR32;

-typedef struct VkCopyMicromapInfoEXT32
+typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkMicromapEXT DECLSPEC_ALIGN(8) src;
-    VkMicromapEXT DECLSPEC_ALIGN(8) dst;
-    VkCopyMicromapModeEXT mode;
-} VkCopyMicromapInfoEXT32;
+    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
+    VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructureNV;
+} VkAccelerationStructureCaptureDescriptorDataInfoEXT32;

-typedef struct VkCopyMicromapToMemoryInfoEXT32
+typedef struct VkAccelerationStructureCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkMicromapEXT DECLSPEC_ALIGN(8) src;
-    VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
-    VkCopyMicromapModeEXT mode;
-} VkCopyMicromapToMemoryInfoEXT32;
+    VkAccelerationStructureCreateFlagsKHR createFlags;
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+    VkDeviceSize DECLSPEC_ALIGN(8) offset;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+    VkAccelerationStructureTypeKHR type;
+    VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
+} VkAccelerationStructureCreateInfoKHR32;

-typedef struct VkTensorCopyARM32
+typedef struct VkAccelerationStructureCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t dimensionCount;
-    PTR32 pSrcOffset;
-    PTR32 pDstOffset;
-    PTR32 pExtent;
-} VkTensorCopyARM32;
+    VkDeviceSize DECLSPEC_ALIGN(8) compactedSize;
+    VkAccelerationStructureInfoNV32 info;
+} VkAccelerationStructureCreateInfoNV32;

-typedef struct VkCopyTensorInfoARM32
+typedef struct VkAccelerationStructureDeviceAddressInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkTensorARM DECLSPEC_ALIGN(8) srcTensor;
-    VkTensorARM DECLSPEC_ALIGN(8) dstTensor;
-    uint32_t regionCount;
-    PTR32 pRegions;
-} VkCopyTensorInfoARM32;
+    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
+} VkAccelerationStructureDeviceAddressInfoKHR32;

-typedef struct VkCuLaunchInfoNVX32
+typedef struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
-    uint32_t gridDimX;
-    uint32_t gridDimY;
-    uint32_t gridDimZ;
-    uint32_t blockDimX;
-    uint32_t blockDimY;
-    uint32_t blockDimZ;
-    uint32_t sharedMemBytes;
-    PTR32 paramCount;
-    PTR32 pParams;
-    PTR32 extraCount;
-    PTR32 pExtras;
-} VkCuLaunchInfoNVX32;
+    VkFormat vertexFormat;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData;
+    VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
+    VkFormat radiusFormat;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) radiusData;
+    VkDeviceSize DECLSPEC_ALIGN(8) radiusStride;
+    VkIndexType indexType;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData;
+    VkDeviceSize DECLSPEC_ALIGN(8) indexStride;
+    VkRayTracingLssIndexingModeNV indexingMode;
+    VkRayTracingLssPrimitiveEndCapsModeNV endCapsMode;
+} VkAccelerationStructureGeometryLinearSweptSpheresDataNV32;

-typedef struct VkDebugMarkerMarkerInfoEXT32
+typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pMarkerName;
-    float color[4];
-} VkDebugMarkerMarkerInfoEXT32;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData;
+} VkAccelerationStructureGeometryMotionTrianglesDataNV32;

-typedef struct StdVideoDecodeVP9PictureInfo32
+typedef struct VkAccelerationStructureGeometrySpheresDataNV32
 {
-    StdVideoDecodeVP9PictureInfoFlags flags;
-    StdVideoVP9Profile profile;
-    StdVideoVP9FrameType frame_type;
-    uint8_t frame_context_idx;
-    uint8_t reset_frame_context;
-    uint8_t refresh_frame_flags;
-    uint8_t ref_frame_sign_bias_mask;
-    StdVideoVP9InterpolationFilter interpolation_filter;
-    uint8_t base_q_idx;
-    int8_t delta_q_y_dc;
-    int8_t delta_q_uv_dc;
-    int8_t delta_q_uv_ac;
-    uint8_t tile_cols_log2;
-    uint8_t tile_rows_log2;
-    uint16_t reserved1[3];
-    PTR32 pColorConfig;
-    PTR32 pLoopFilter;
-    PTR32 pSegmentation;
-} StdVideoDecodeVP9PictureInfo32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkFormat vertexFormat;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData;
+    VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
+    VkFormat radiusFormat;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) radiusData;
+    VkDeviceSize DECLSPEC_ALIGN(8) radiusStride;
+    VkIndexType indexType;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData;
+    VkDeviceSize DECLSPEC_ALIGN(8) indexStride;
+} VkAccelerationStructureGeometrySpheresDataNV32;

-typedef struct StdVideoAV1TileInfo32
+typedef struct VkAccelerationStructureMemoryRequirementsInfoNV32
 {
-    StdVideoAV1TileInfoFlags flags;
-    uint8_t TileCols;
-    uint8_t TileRows;
-    uint16_t context_update_tile_id;
-    uint8_t tile_size_bytes_minus_1;
-    uint8_t reserved1[7];
-    PTR32 pMiColStarts;
-    PTR32 pMiRowStarts;
-    PTR32 pWidthInSbsMinus1;
-    PTR32 pHeightInSbsMinus1;
-} StdVideoAV1TileInfo32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkAccelerationStructureMemoryRequirementsTypeNV type;
+    VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
+} VkAccelerationStructureMemoryRequirementsInfoNV32;

-typedef struct StdVideoDecodeAV1PictureInfo32
-{
-    StdVideoDecodeAV1PictureInfoFlags flags;
-    StdVideoAV1FrameType frame_type;
-    uint32_t current_frame_id;
-    uint8_t OrderHint;
-    uint8_t primary_ref_frame;
-    uint8_t refresh_frame_flags;
-    uint8_t reserved1;
-    StdVideoAV1InterpolationFilter interpolation_filter;
-    StdVideoAV1TxMode TxMode;
-    uint8_t delta_q_res;
-    uint8_t delta_lf_res;
-    uint8_t SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES];
-    uint8_t coded_denom;
-    uint8_t reserved2[3];
-    uint8_t OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES];
-    uint32_t expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES];
-    PTR32 pTileInfo;
-    PTR32 pQuantization;
-    PTR32 pSegmentation;
-    PTR32 pLoopFilter;
-    PTR32 pCDEF;
-    PTR32 pLoopRestoration;
-    PTR32 pGlobalMotion;
-    PTR32 pFilmGrain;
-} StdVideoDecodeAV1PictureInfo32;
+typedef struct VkAccelerationStructureMotionInfoNV32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t maxInstances;
+    VkAccelerationStructureMotionInfoFlagsNV flags;
+} VkAccelerationStructureMotionInfoNV32;

-typedef struct VkVideoInlineQueryInfoKHR32
+typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkQueryPool DECLSPEC_ALIGN(8) queryPool;
-    uint32_t firstQuery;
-    uint32_t queryCount;
-} VkVideoInlineQueryInfoKHR32;
+    VkIndexType indexType;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexBuffer;
+    VkDeviceSize DECLSPEC_ALIGN(8) indexStride;
+    uint32_t baseTriangle;
+    uint32_t usageCountsCount;
+    PTR32 pUsageCounts;
+    PTR32 ppUsageCounts;
+    VkMicromapEXT DECLSPEC_ALIGN(8) micromap;
+} VkAccelerationStructureTrianglesOpacityMicromapEXT32;

-typedef struct VkVideoDecodeH264PictureInfoKHR32
+typedef struct VkAccelerationStructureVersionInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pStdPictureInfo;
-    uint32_t sliceCount;
-    PTR32 pSliceOffsets;
-} VkVideoDecodeH264PictureInfoKHR32;
+    PTR32 pVersionData;
+} VkAccelerationStructureVersionInfoKHR32;

-typedef struct VkVideoDecodeVP9PictureInfoKHR32
+typedef struct VkAcquireNextImageInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pStdPictureInfo;
-    int32_t referenceNameSlotIndices[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR];
-    uint32_t uncompressedHeaderOffset;
-    uint32_t compressedHeaderOffset;
-    uint32_t tilesOffset;
-} VkVideoDecodeVP9PictureInfoKHR32;
+    VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
+    uint64_t DECLSPEC_ALIGN(8) timeout;
+    VkSemaphore DECLSPEC_ALIGN(8) semaphore;
+    VkFence DECLSPEC_ALIGN(8) fence;
+    uint32_t deviceMask;
+} VkAcquireNextImageInfoKHR32;

-typedef struct VkVideoDecodeAV1PictureInfoKHR32
+typedef struct VkAcquireProfilingLockInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pStdPictureInfo;
-    int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR];
-    uint32_t frameHeaderOffset;
-    uint32_t tileCount;
-    PTR32 pTileOffsets;
-    PTR32 pTileSizes;
-} VkVideoDecodeAV1PictureInfoKHR32;
+    VkAcquireProfilingLockFlagsKHR flags;
+    uint64_t DECLSPEC_ALIGN(8) timeout;
+} VkAcquireProfilingLockInfoKHR32;

-typedef struct VkVideoDecodeInfoKHR32
+typedef struct VkAntiLagDataAMD32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoDecodeFlagsKHR flags;
-    VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
-    VkDeviceSize DECLSPEC_ALIGN(8) srcBufferOffset;
-    VkDeviceSize DECLSPEC_ALIGN(8) srcBufferRange;
-    VkVideoPictureResourceInfoKHR32 DECLSPEC_ALIGN(8) dstPictureResource;
-    PTR32 pSetupReferenceSlot;
-    uint32_t referenceSlotCount;
-    PTR32 pReferenceSlots;
-} VkVideoDecodeInfoKHR32;
+    VkAntiLagModeAMD mode;
+    uint32_t maxFPS;
+    PTR32 pPresentationInfo;
+} VkAntiLagDataAMD32;

-typedef struct VkDecompressMemoryRegionNV32
+typedef struct VkAttachmentDescriptionStencilLayout32
 {
-    VkDeviceAddress DECLSPEC_ALIGN(8) srcAddress;
-    VkDeviceAddress DECLSPEC_ALIGN(8) dstAddress;
-    VkDeviceSize DECLSPEC_ALIGN(8) compressedSize;
-    VkDeviceSize DECLSPEC_ALIGN(8) decompressedSize;
-    VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethod;
-} VkDecompressMemoryRegionNV32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkImageLayout stencilInitialLayout;
+    VkImageLayout stencilFinalLayout;
+} VkAttachmentDescriptionStencilLayout32;
+typedef VkAttachmentDescriptionStencilLayout32 VkAttachmentDescriptionStencilLayoutKHR32;

-typedef struct VkDataGraphPipelineDispatchInfoARM32
+typedef struct VkAttachmentFeedbackLoopInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDataGraphPipelineDispatchFlagsARM DECLSPEC_ALIGN(8) flags;
-} VkDataGraphPipelineDispatchInfoARM32;
+    VkBool32 feedbackLoopEnable;
+} VkAttachmentFeedbackLoopInfoEXT32;

-typedef struct VkDispatchTileInfoQCOM32
+typedef struct VkAttachmentReferenceStencilLayout32
 {
     VkStructureType sType;
     PTR32 pNext;
-} VkDispatchTileInfoQCOM32;
+    VkImageLayout stencilLayout;
+} VkAttachmentReferenceStencilLayout32;
+typedef VkAttachmentReferenceStencilLayout32 VkAttachmentReferenceStencilLayoutKHR32;

-typedef struct StdVideoEncodeH264SliceHeader32
+typedef struct VkAttachmentSampleCountInfoAMD32
 {
-    StdVideoEncodeH264SliceHeaderFlags flags;
-    uint32_t first_mb_in_slice;
-    StdVideoH264SliceType slice_type;
-    int8_t slice_alpha_c0_offset_div2;
-    int8_t slice_beta_offset_div2;
-    int8_t slice_qp_delta;
-    uint8_t reserved1;
-    StdVideoH264CabacInitIdc cabac_init_idc;
-    StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc;
-    PTR32 pWeightTable;
-} StdVideoEncodeH264SliceHeader32;
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t colorAttachmentCount;
+    PTR32 pColorAttachmentSamples;
+    VkSampleCountFlagBits depthStencilAttachmentSamples;
+} VkAttachmentSampleCountInfoAMD32;
+typedef VkAttachmentSampleCountInfoAMD32 VkAttachmentSampleCountInfoNV32;

-typedef struct VkVideoEncodeH264NaluSliceInfoKHR32
+typedef struct VkBindAccelerationStructureMemoryInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    int32_t constantQp;
-    PTR32 pStdSliceHeader;
-} VkVideoEncodeH264NaluSliceInfoKHR32;
+    VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
+    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
+    VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
+    uint32_t deviceIndexCount;
+    PTR32 pDeviceIndices;
+} VkBindAccelerationStructureMemoryInfoNV32;

-typedef struct StdVideoEncodeH264ReferenceListsInfo32
+typedef struct VkBindBufferMemoryDeviceGroupInfo32
 {
-    StdVideoEncodeH264ReferenceListsInfoFlags flags;
-    uint8_t num_ref_idx_l0_active_minus1;
-    uint8_t num_ref_idx_l1_active_minus1;
-    uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF];
-    uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF];
-    uint8_t refList0ModOpCount;
-    uint8_t refList1ModOpCount;
-    uint8_t refPicMarkingOpCount;
-    uint8_t reserved1[7];
-    PTR32 pRefList0ModOperations;
-    PTR32 pRefList1ModOperations;
-    PTR32 pRefPicMarkingOperations;
-} StdVideoEncodeH264ReferenceListsInfo32;
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t deviceIndexCount;
+    PTR32 pDeviceIndices;
+} VkBindBufferMemoryDeviceGroupInfo32;
+typedef VkBindBufferMemoryDeviceGroupInfo32 VkBindBufferMemoryDeviceGroupInfoKHR32;

-typedef struct StdVideoEncodeH264PictureInfo32
+typedef struct VkBindBufferMemoryInfo32
 {
-    StdVideoEncodeH264PictureInfoFlags flags;
-    uint8_t seq_parameter_set_id;
-    uint8_t pic_parameter_set_id;
-    uint16_t idr_pic_id;
-    StdVideoH264PictureType primary_pic_type;
-    uint32_t frame_num;
-    int32_t PicOrderCnt;
-    uint8_t temporal_id;
-    uint8_t reserved1[3];
-    PTR32 pRefLists;
-} StdVideoEncodeH264PictureInfo32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
+    VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
+} VkBindBufferMemoryInfo32;
+typedef VkBindBufferMemoryInfo32 VkBindBufferMemoryInfoKHR32;

-typedef struct StdVideoEncodeAV1PictureInfo32
+typedef struct VkBindDataGraphPipelineSessionMemoryInfoARM32
 {
-    StdVideoEncodeAV1PictureInfoFlags flags;
-    StdVideoAV1FrameType frame_type;
-    uint32_t frame_presentation_time;
-    uint32_t current_frame_id;
-    uint8_t order_hint;
-    uint8_t primary_ref_frame;
-    uint8_t refresh_frame_flags;
-    uint8_t coded_denom;
-    uint16_t render_width_minus_1;
-    uint16_t render_height_minus_1;
-    StdVideoAV1InterpolationFilter interpolation_filter;
-    StdVideoAV1TxMode TxMode;
-    uint8_t delta_q_res;
-    uint8_t delta_lf_res;
-    uint8_t ref_order_hint[STD_VIDEO_AV1_NUM_REF_FRAMES];
-    int8_t ref_frame_idx[STD_VIDEO_AV1_REFS_PER_FRAME];
-    uint8_t reserved1[3];
-    uint32_t delta_frame_id_minus_1[STD_VIDEO_AV1_REFS_PER_FRAME];
-    PTR32 pTileInfo;
-    PTR32 pQuantization;
-    PTR32 pSegmentation;
-    PTR32 pLoopFilter;
-    PTR32 pCDEF;
-    PTR32 pLoopRestoration;
-    PTR32 pGlobalMotion;
-    PTR32 pExtensionHeader;
-    PTR32 pBufferRemovalTimes;
-} StdVideoEncodeAV1PictureInfo32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session;
+    VkDataGraphPipelineSessionBindPointARM bindPoint;
+    uint32_t objectIndex;
+    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
+    VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
+} VkBindDataGraphPipelineSessionMemoryInfoARM32;

-typedef struct VkVideoEncodeQuantizationMapInfoKHR32
+typedef struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageView DECLSPEC_ALIGN(8) quantizationMap;
-    VkExtent2D quantizationMapExtent;
-} VkVideoEncodeQuantizationMapInfoKHR32;
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
+    uint32_t set;
+} VkBindDescriptorBufferEmbeddedSamplersInfoEXT32;

-typedef struct VkVideoEncodeH264PictureInfoKHR32
+typedef struct VkBindDescriptorSetsInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t naluSliceEntryCount;
-    PTR32 pNaluSliceEntries;
-    PTR32 pStdPictureInfo;
-    VkBool32 generatePrefixNalu;
-} VkVideoEncodeH264PictureInfoKHR32;
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
+    uint32_t firstSet;
+    uint32_t descriptorSetCount;
+    PTR32 pDescriptorSets;
+    uint32_t dynamicOffsetCount;
+    PTR32 pDynamicOffsets;
+} VkBindDescriptorSetsInfo32;
+typedef VkBindDescriptorSetsInfo32 VkBindDescriptorSetsInfoKHR32;

-typedef struct VkVideoEncodeAV1PictureInfoKHR32
+typedef struct VkBindImageMemoryDeviceGroupInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeAV1PredictionModeKHR predictionMode;
-    VkVideoEncodeAV1RateControlGroupKHR rateControlGroup;
-    uint32_t constantQIndex;
-    PTR32 pStdPictureInfo;
-    int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR];
-    VkBool32 primaryReferenceCdfOnly;
-    VkBool32 generateObuExtensionHeader;
-} VkVideoEncodeAV1PictureInfoKHR32;
+    uint32_t deviceIndexCount;
+    PTR32 pDeviceIndices;
+    uint32_t splitInstanceBindRegionCount;
+    PTR32 pSplitInstanceBindRegions;
+} VkBindImageMemoryDeviceGroupInfo32;
+typedef VkBindImageMemoryDeviceGroupInfo32 VkBindImageMemoryDeviceGroupInfoKHR32;

-typedef struct VkVideoEncodeIntraRefreshInfoKHR32
+typedef struct VkBindImageMemoryInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t intraRefreshCycleDuration;
-    uint32_t intraRefreshIndex;
-} VkVideoEncodeIntraRefreshInfoKHR32;
+    VkImage DECLSPEC_ALIGN(8) image;
+    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
+    VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
+} VkBindImageMemoryInfo32;
+typedef VkBindImageMemoryInfo32 VkBindImageMemoryInfoKHR32;

-typedef struct VkVideoEncodeInfoKHR32
+typedef struct VkBindImageMemorySwapchainInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeFlagsKHR flags;
-    VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
-    VkDeviceSize DECLSPEC_ALIGN(8) dstBufferOffset;
-    VkDeviceSize DECLSPEC_ALIGN(8) dstBufferRange;
-    VkVideoPictureResourceInfoKHR32 DECLSPEC_ALIGN(8) srcPictureResource;
-    PTR32 pSetupReferenceSlot;
-    uint32_t referenceSlotCount;
-    PTR32 pReferenceSlots;
-    uint32_t precedingExternallyEncodedBytes;
-} VkVideoEncodeInfoKHR32;
+    VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
+    uint32_t imageIndex;
+} VkBindImageMemorySwapchainInfoKHR32;

-typedef struct VkPerTileEndInfoQCOM32
+typedef struct VkBindImagePlaneMemoryInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-} VkPerTileEndInfoQCOM32;
+    VkImageAspectFlagBits planeAspect;
+} VkBindImagePlaneMemoryInfo32;
+typedef VkBindImagePlaneMemoryInfo32 VkBindImagePlaneMemoryInfoKHR32;

-typedef struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT32
+typedef struct VkBindMemoryStatus32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t fragmentDensityOffsetCount;
-    PTR32 pFragmentDensityOffsets;
-} VkRenderPassFragmentDensityMapOffsetEndInfoEXT32;
-typedef VkRenderPassFragmentDensityMapOffsetEndInfoEXT32 VkSubpassFragmentDensityMapOffsetEndInfoQCOM32;
+    PTR32 pResult;
+} VkBindMemoryStatus32;
+typedef VkBindMemoryStatus32 VkBindMemoryStatusKHR32;

-typedef struct VkSubpassEndInfo32
+typedef struct VkBindSparseInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-} VkSubpassEndInfo32;
-typedef VkSubpassEndInfo32 VkSubpassEndInfoKHR32;
+    uint32_t waitSemaphoreCount;
+    PTR32 pWaitSemaphores;
+    uint32_t bufferBindCount;
+    PTR32 pBufferBinds;
+    uint32_t imageOpaqueBindCount;
+    PTR32 pImageOpaqueBinds;
+    uint32_t imageBindCount;
+    PTR32 pImageBinds;
+    uint32_t signalSemaphoreCount;
+    PTR32 pSignalSemaphores;
+} VkBindSparseInfo32;

-typedef struct VkRenderingEndInfoEXT32
+typedef struct VkBindTensorMemoryInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-} VkRenderingEndInfoEXT32;
+    VkTensorARM DECLSPEC_ALIGN(8) tensor;
+    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
+    VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
+} VkBindTensorMemoryInfoARM32;

-typedef struct VkVideoEndCodingInfoKHR32
+typedef struct VkBindVideoSessionMemoryInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEndCodingFlagsKHR flags;
-} VkVideoEndCodingInfoKHR32;
+    uint32_t memoryBindIndex;
+    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
+    VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
+    VkDeviceSize DECLSPEC_ALIGN(8) memorySize;
+} VkBindVideoSessionMemoryInfoKHR32;

-typedef struct VkGeneratedCommandsPipelineInfoEXT32
+typedef struct VkBlitImageCubicWeightsInfoQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipeline DECLSPEC_ALIGN(8) pipeline;
-} VkGeneratedCommandsPipelineInfoEXT32;
+    VkCubicFilterWeightsQCOM cubicWeights;
+} VkBlitImageCubicWeightsInfoQCOM32;

-typedef struct VkGeneratedCommandsShaderInfoEXT32
+typedef struct VkBlitImageInfo232
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t shaderCount;
-    PTR32 pShaders;
-} VkGeneratedCommandsShaderInfoEXT32;
+    VkImage DECLSPEC_ALIGN(8) srcImage;
+    VkImageLayout srcImageLayout;
+    VkImage DECLSPEC_ALIGN(8) dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    PTR32 pRegions;
+    VkFilter filter;
+} VkBlitImageInfo232;
+typedef VkBlitImageInfo232 VkBlitImageInfo2KHR32;

-typedef struct VkGeneratedCommandsInfoEXT32
+typedef struct VkBufferCaptureDescriptorDataInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderStageFlags shaderStages;
-    VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet;
-    VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout;
-    VkDeviceAddress DECLSPEC_ALIGN(8) indirectAddress;
-    VkDeviceSize DECLSPEC_ALIGN(8) indirectAddressSize;
-    VkDeviceAddress DECLSPEC_ALIGN(8) preprocessAddress;
-    VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize;
-    uint32_t maxSequenceCount;
-    VkDeviceAddress DECLSPEC_ALIGN(8) sequenceCountAddress;
-    uint32_t maxDrawCount;
-} VkGeneratedCommandsInfoEXT32;
-
-typedef struct VkIndirectCommandsStreamNV32
-{
     VkBuffer DECLSPEC_ALIGN(8) buffer;
-    VkDeviceSize DECLSPEC_ALIGN(8) offset;
-} VkIndirectCommandsStreamNV32;
+} VkBufferCaptureDescriptorDataInfoEXT32;

-typedef struct VkGeneratedCommandsInfoNV32
+typedef struct VkBufferCopy32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkPipelineBindPoint pipelineBindPoint;
-    VkPipeline DECLSPEC_ALIGN(8) pipeline;
-    VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
-    uint32_t streamCount;
-    PTR32 pStreams;
-    uint32_t sequencesCount;
-    VkBuffer DECLSPEC_ALIGN(8) preprocessBuffer;
-    VkDeviceSize DECLSPEC_ALIGN(8) preprocessOffset;
-    VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize;
-    VkBuffer DECLSPEC_ALIGN(8) sequencesCountBuffer;
-    VkDeviceSize DECLSPEC_ALIGN(8) sequencesCountOffset;
-    VkBuffer DECLSPEC_ALIGN(8) sequencesIndexBuffer;
-    VkDeviceSize DECLSPEC_ALIGN(8) sequencesIndexOffset;
-} VkGeneratedCommandsInfoNV32;
+    VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
+    VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+} VkBufferCopy32;

-typedef struct VkOpticalFlowExecuteInfoNV32
+typedef struct VkBufferDeviceAddressCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkOpticalFlowExecuteFlagsNV flags;
-    uint32_t regionCount;
-    PTR32 pRegions;
-} VkOpticalFlowExecuteInfoNV32;
+    VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
+} VkBufferDeviceAddressCreateInfoEXT32;

-typedef struct VkMemoryBarrier32
+typedef struct VkBufferDeviceAddressInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAccessFlags srcAccessMask;
-    VkAccessFlags dstAccessMask;
-} VkMemoryBarrier32;
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+} VkBufferDeviceAddressInfo32;
+typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoKHR32;
+typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoEXT32;

-typedef struct VkExternalMemoryAcquireUnmodifiedEXT32
+typedef struct VkBufferImageCopy32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkBool32 acquireUnmodifiedMemory;
-} VkExternalMemoryAcquireUnmodifiedEXT32;
+    VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
+    uint32_t bufferRowLength;
+    uint32_t bufferImageHeight;
+    VkImageSubresourceLayers imageSubresource;
+    VkOffset3D imageOffset;
+    VkExtent3D imageExtent;
+} VkBufferImageCopy32;

typedef struct VkBufferMemoryBarrier32
 {
@@ -1774,321 +2021,343 @@ typedef struct VkBufferMemoryBarrier32
     VkDeviceSize DECLSPEC_ALIGN(8) size;
 } VkBufferMemoryBarrier32;

-typedef struct VkImageMemoryBarrier32
+typedef struct VkBufferMemoryRequirementsInfo232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAccessFlags srcAccessMask;
-    VkAccessFlags dstAccessMask;
-    VkImageLayout oldLayout;
-    VkImageLayout newLayout;
-    uint32_t srcQueueFamilyIndex;
-    uint32_t dstQueueFamilyIndex;
-    VkImage DECLSPEC_ALIGN(8) image;
-    VkImageSubresourceRange subresourceRange;
-} VkImageMemoryBarrier32;
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+} VkBufferMemoryRequirementsInfo232;
+typedef VkBufferMemoryRequirementsInfo232 VkBufferMemoryRequirementsInfo2KHR32;

-typedef struct VkTensorMemoryBarrierARM32
+typedef struct VkBufferOpaqueCaptureAddressCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
-    VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
-    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
-    VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
-    uint32_t srcQueueFamilyIndex;
-    uint32_t dstQueueFamilyIndex;
-    VkTensorARM DECLSPEC_ALIGN(8) tensor;
-} VkTensorMemoryBarrierARM32;
+    uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
+} VkBufferOpaqueCaptureAddressCreateInfo32;
+typedef VkBufferOpaqueCaptureAddressCreateInfo32 VkBufferOpaqueCaptureAddressCreateInfoKHR32;

-typedef struct VkMemoryBarrier232
+typedef struct VkBufferUsageFlags2CreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
-    VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
-    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
-    VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
-} VkMemoryBarrier232;
-typedef VkMemoryBarrier232 VkMemoryBarrier2KHR32;
+    VkBufferUsageFlags2 DECLSPEC_ALIGN(8) usage;
+} VkBufferUsageFlags2CreateInfo32;
+typedef VkBufferUsageFlags2CreateInfo32 VkBufferUsageFlags2CreateInfoKHR32;

-typedef struct VkMemoryBarrierAccessFlags3KHR32
+typedef struct VkBufferViewCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAccessFlags3KHR DECLSPEC_ALIGN(8) srcAccessMask3;
-    VkAccessFlags3KHR DECLSPEC_ALIGN(8) dstAccessMask3;
-} VkMemoryBarrierAccessFlags3KHR32;
+    VkBufferViewCreateFlags flags;
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+    VkFormat format;
+    VkDeviceSize DECLSPEC_ALIGN(8) offset;
+    VkDeviceSize DECLSPEC_ALIGN(8) range;
+} VkBufferViewCreateInfo32;

-typedef struct VkBufferMemoryBarrier232
+typedef struct VkBuildPartitionedAccelerationStructureInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
-    VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
-    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
-    VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
-    uint32_t srcQueueFamilyIndex;
-    uint32_t dstQueueFamilyIndex;
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-    VkDeviceSize DECLSPEC_ALIGN(8) offset;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-} VkBufferMemoryBarrier232;
-typedef VkBufferMemoryBarrier232 VkBufferMemoryBarrier2KHR32;
+    VkPartitionedAccelerationStructureInstancesInputNV32 input;
+    VkDeviceAddress DECLSPEC_ALIGN(8) srcAccelerationStructureData;
+    VkDeviceAddress DECLSPEC_ALIGN(8) dstAccelerationStructureData;
+    VkDeviceAddress DECLSPEC_ALIGN(8) scratchData;
+    VkDeviceAddress DECLSPEC_ALIGN(8) srcInfos;
+    VkDeviceAddress DECLSPEC_ALIGN(8) srcInfosCount;
+} VkBuildPartitionedAccelerationStructureInfoNV32;

-typedef struct VkImageMemoryBarrier232
+typedef struct VkCalibratedTimestampInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
-    VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
-    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
-    VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
-    VkImageLayout oldLayout;
-    VkImageLayout newLayout;
-    uint32_t srcQueueFamilyIndex;
-    uint32_t dstQueueFamilyIndex;
-    VkImage DECLSPEC_ALIGN(8) image;
-    VkImageSubresourceRange subresourceRange;
-} VkImageMemoryBarrier232;
-typedef VkImageMemoryBarrier232 VkImageMemoryBarrier2KHR32;
+    VkTimeDomainKHR timeDomain;
+} VkCalibratedTimestampInfoKHR32;
+typedef VkCalibratedTimestampInfoKHR32 VkCalibratedTimestampInfoEXT32;

-typedef struct VkTensorDependencyInfoARM32
+typedef struct VkCheckpointData2NV32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
+    PTR32 pCheckpointMarker;
+} VkCheckpointData2NV32;
+
+typedef struct VkCheckpointDataNV32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkPipelineStageFlagBits stage;
+    PTR32 pCheckpointMarker;
+} VkCheckpointDataNV32;
+
+typedef struct VkClusterAccelerationStructureCommandsInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t tensorMemoryBarrierCount;
-    PTR32 pTensorMemoryBarriers;
-} VkTensorDependencyInfoARM32;
+    VkClusterAccelerationStructureInputInfoNV32 input;
+    VkDeviceAddress DECLSPEC_ALIGN(8) dstImplicitData;
+    VkDeviceAddress DECLSPEC_ALIGN(8) scratchData;
+    VkStridedDeviceAddressRegionKHR32 DECLSPEC_ALIGN(8) dstAddressesArray;
+    VkStridedDeviceAddressRegionKHR32 DECLSPEC_ALIGN(8) dstSizesArray;
+    VkStridedDeviceAddressRegionKHR32 DECLSPEC_ALIGN(8) srcInfosArray;
+    VkDeviceAddress DECLSPEC_ALIGN(8) srcInfosCount;
+    VkClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags;
+} VkClusterAccelerationStructureCommandsInfoNV32;

-typedef struct VkDependencyInfo32
+typedef struct VkCommandBufferAllocateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDependencyFlags dependencyFlags;
-    uint32_t memoryBarrierCount;
-    PTR32 pMemoryBarriers;
-    uint32_t bufferMemoryBarrierCount;
-    PTR32 pBufferMemoryBarriers;
-    uint32_t imageMemoryBarrierCount;
-    PTR32 pImageMemoryBarriers;
-} VkDependencyInfo32;
-typedef VkDependencyInfo32 VkDependencyInfoKHR32;
+    VkCommandPool DECLSPEC_ALIGN(8) commandPool;
+    VkCommandBufferLevel level;
+    uint32_t commandBufferCount;
+} VkCommandBufferAllocateInfo32;

-typedef struct VkPushConstantsInfo32
+typedef struct VkCommandBufferBeginInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
-    VkShaderStageFlags stageFlags;
-    uint32_t offset;
-    uint32_t size;
-    PTR32 pValues;
-} VkPushConstantsInfo32;
-typedef VkPushConstantsInfo32 VkPushConstantsInfoKHR32;
+    VkCommandBufferUsageFlags flags;
+    PTR32 pInheritanceInfo;
+} VkCommandBufferBeginInfo32;

-typedef struct VkDescriptorImageInfo32
+typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT32
 {
-    VkSampler DECLSPEC_ALIGN(8) sampler;
-    VkImageView DECLSPEC_ALIGN(8) imageView;
-    VkImageLayout imageLayout;
-} VkDescriptorImageInfo32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 conditionalRenderingEnable;
+} VkCommandBufferInheritanceConditionalRenderingInfoEXT32;

-typedef struct VkDescriptorBufferInfo32
+typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM32
 {
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-    VkDeviceSize DECLSPEC_ALIGN(8) offset;
-    VkDeviceSize DECLSPEC_ALIGN(8) range;
-} VkDescriptorBufferInfo32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkSurfaceTransformFlagBitsKHR transform;
+    VkRect2D renderArea;
+} VkCommandBufferInheritanceRenderPassTransformInfoQCOM32;

-typedef struct VkWriteDescriptorSetInlineUniformBlock32
+typedef struct VkCommandBufferInheritanceRenderingInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t dataSize;
-    PTR32 pData;
-} VkWriteDescriptorSetInlineUniformBlock32;
-typedef VkWriteDescriptorSetInlineUniformBlock32 VkWriteDescriptorSetInlineUniformBlockEXT32;
+    VkRenderingFlags flags;
+    uint32_t viewMask;
+    uint32_t colorAttachmentCount;
+    PTR32 pColorAttachmentFormats;
+    VkFormat depthAttachmentFormat;
+    VkFormat stencilAttachmentFormat;
+    VkSampleCountFlagBits rasterizationSamples;
+} VkCommandBufferInheritanceRenderingInfo32;
+typedef VkCommandBufferInheritanceRenderingInfo32 VkCommandBufferInheritanceRenderingInfoKHR32;

-typedef struct VkWriteDescriptorSetAccelerationStructureKHR32
+typedef struct VkCommandBufferInheritanceViewportScissorInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t accelerationStructureCount;
-    PTR32 pAccelerationStructures;
-} VkWriteDescriptorSetAccelerationStructureKHR32;
+    VkBool32 viewportScissor2D;
+    uint32_t viewportDepthCount;
+    PTR32 pViewportDepths;
+} VkCommandBufferInheritanceViewportScissorInfoNV32;

-typedef struct VkWriteDescriptorSetAccelerationStructureNV32
+typedef struct VkCommandPoolCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t accelerationStructureCount;
-    PTR32 pAccelerationStructures;
-} VkWriteDescriptorSetAccelerationStructureNV32;
+    VkCommandPoolCreateFlags flags;
+    uint32_t queueFamilyIndex;
+} VkCommandPoolCreateInfo32;

-typedef struct VkWriteDescriptorSetPartitionedAccelerationStructureNV32
+typedef struct VkComputePipelineCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t accelerationStructureCount;
-    PTR32 pAccelerationStructures;
-} VkWriteDescriptorSetPartitionedAccelerationStructureNV32;
+    VkPipelineCreateFlags flags;
+    VkPipelineShaderStageCreateInfo32 DECLSPEC_ALIGN(8) stage;
+    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
+    VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
+    int32_t basePipelineIndex;
+} VkComputePipelineCreateInfo32;

-typedef struct VkWriteDescriptorSetTensorARM32
+typedef struct VkComputePipelineIndirectBufferInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t tensorViewCount;
-    PTR32 pTensorViews;
-} VkWriteDescriptorSetTensorARM32;
+    VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+    VkDeviceAddress DECLSPEC_ALIGN(8) pipelineDeviceAddressCaptureReplay;
+} VkComputePipelineIndirectBufferInfoNV32;

-typedef struct VkWriteDescriptorSet32
+typedef struct VkConditionalRenderingBeginInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
-    uint32_t dstBinding;
-    uint32_t dstArrayElement;
-    uint32_t descriptorCount;
-    VkDescriptorType descriptorType;
-    PTR32 pImageInfo;
-    PTR32 pBufferInfo;
-    PTR32 pTexelBufferView;
-} VkWriteDescriptorSet32;
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+    VkDeviceSize DECLSPEC_ALIGN(8) offset;
+    VkConditionalRenderingFlagsEXT flags;
+} VkConditionalRenderingBeginInfoEXT32;

-typedef struct VkPushDescriptorSetInfo32
+typedef struct VkConvertCooperativeVectorMatrixInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderStageFlags stageFlags;
-    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
-    uint32_t set;
-    uint32_t descriptorWriteCount;
-    PTR32 pDescriptorWrites;
-} VkPushDescriptorSetInfo32;
-typedef VkPushDescriptorSetInfo32 VkPushDescriptorSetInfoKHR32;
+    PTR32 srcSize;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) srcData;
+    PTR32 pDstSize;
+    VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dstData;
+    VkComponentTypeKHR srcComponentType;
+    VkComponentTypeKHR dstComponentType;
+    uint32_t numRows;
+    uint32_t numColumns;
+    VkCooperativeVectorMatrixLayoutNV srcLayout;
+    PTR32 srcStride;
+    VkCooperativeVectorMatrixLayoutNV dstLayout;
+    PTR32 dstStride;
+} VkConvertCooperativeVectorMatrixInfoNV32;

-typedef struct VkPushDescriptorSetWithTemplateInfo32
+typedef struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
-    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
-    uint32_t set;
-    PTR32 pData;
-} VkPushDescriptorSetWithTemplateInfo32;
-typedef VkPushDescriptorSetWithTemplateInfo32 VkPushDescriptorSetWithTemplateInfoKHR32;
+    uint32_t MGranularity;
+    uint32_t NGranularity;
+    uint32_t KGranularity;
+    VkComponentTypeKHR AType;
+    VkComponentTypeKHR BType;
+    VkComponentTypeKHR CType;
+    VkComponentTypeKHR ResultType;
+    VkBool32 saturatingAccumulation;
+    VkScopeKHR scope;
+    uint32_t workgroupInvocations;
+} VkCooperativeMatrixFlexibleDimensionsPropertiesNV32;

-typedef struct VkImageResolve232
+typedef struct VkCooperativeMatrixPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageSubresourceLayers srcSubresource;
-    VkOffset3D srcOffset;
-    VkImageSubresourceLayers dstSubresource;
-    VkOffset3D dstOffset;
-    VkExtent3D extent;
-} VkImageResolve232;
-typedef VkImageResolve232 VkImageResolve2KHR32;
+    uint32_t MSize;
+    uint32_t NSize;
+    uint32_t KSize;
+    VkComponentTypeKHR AType;
+    VkComponentTypeKHR BType;
+    VkComponentTypeKHR CType;
+    VkComponentTypeKHR ResultType;
+    VkBool32 saturatingAccumulation;
+    VkScopeKHR scope;
+} VkCooperativeMatrixPropertiesKHR32;

-typedef struct VkResolveImageInfo232
+typedef struct VkCooperativeMatrixPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImage DECLSPEC_ALIGN(8) srcImage;
-    VkImageLayout srcImageLayout;
-    VkImage DECLSPEC_ALIGN(8) dstImage;
-    VkImageLayout dstImageLayout;
-    uint32_t regionCount;
-    PTR32 pRegions;
-} VkResolveImageInfo232;
-typedef VkResolveImageInfo232 VkResolveImageInfo2KHR32;
+    uint32_t MSize;
+    uint32_t NSize;
+    uint32_t KSize;
+    VkComponentTypeNV AType;
+    VkComponentTypeNV BType;
+    VkComponentTypeNV CType;
+    VkComponentTypeNV DType;
+    VkScopeNV scope;
+} VkCooperativeMatrixPropertiesNV32;

-typedef struct VkCoarseSampleOrderCustomNV32
+typedef struct VkCooperativeVectorPropertiesNV32
 {
-    VkShadingRatePaletteEntryNV shadingRate;
-    uint32_t sampleCount;
-    uint32_t sampleLocationCount;
-    PTR32 pSampleLocations;
-} VkCoarseSampleOrderCustomNV32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkComponentTypeKHR inputType;
+    VkComponentTypeKHR inputInterpretation;
+    VkComponentTypeKHR matrixInterpretation;
+    VkComponentTypeKHR biasInterpretation;
+    VkComponentTypeKHR resultType;
+    VkBool32 transpose;
+} VkCooperativeVectorPropertiesNV32;

-typedef struct VkDepthBiasRepresentationInfoEXT32
+typedef struct VkCopyAccelerationStructureInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDepthBiasRepresentationEXT depthBiasRepresentation;
-    VkBool32 depthBiasExact;
-} VkDepthBiasRepresentationInfoEXT32;
+    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
+    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
+    VkCopyAccelerationStructureModeKHR mode;
+} VkCopyAccelerationStructureInfoKHR32;

-typedef struct VkDepthBiasInfoEXT32
+typedef struct VkCopyAccelerationStructureToMemoryInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    float depthBiasConstantFactor;
-    float depthBiasClamp;
-    float depthBiasSlopeFactor;
-} VkDepthBiasInfoEXT32;
+    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
+    VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
+    VkCopyAccelerationStructureModeKHR mode;
+} VkCopyAccelerationStructureToMemoryInfoKHR32;

-typedef struct VkSetDescriptorBufferOffsetsInfoEXT32
+typedef struct VkCopyBufferInfo232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderStageFlags stageFlags;
-    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
-    uint32_t firstSet;
-    uint32_t setCount;
-    PTR32 pBufferIndices;
-    PTR32 pOffsets;
-} VkSetDescriptorBufferOffsetsInfoEXT32;
+    VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
+    VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
+    uint32_t regionCount;
+    PTR32 pRegions;
+} VkCopyBufferInfo232;
+typedef VkCopyBufferInfo232 VkCopyBufferInfo2KHR32;

-typedef struct VkPerformanceMarkerInfoINTEL32
+typedef struct VkCopyBufferToImageInfo232
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint64_t DECLSPEC_ALIGN(8) marker;
-} VkPerformanceMarkerInfoINTEL32;
+    VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
+    VkImage DECLSPEC_ALIGN(8) dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    PTR32 pRegions;
+} VkCopyBufferToImageInfo232;
+typedef VkCopyBufferToImageInfo232 VkCopyBufferToImageInfo2KHR32;

-typedef struct VkPerformanceOverrideInfoINTEL32
+typedef struct VkCopyCommandTransformInfoQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPerformanceOverrideTypeINTEL type;
-    VkBool32 enable;
-    uint64_t DECLSPEC_ALIGN(8) parameter;
-} VkPerformanceOverrideInfoINTEL32;
+    VkSurfaceTransformFlagBitsKHR transform;
+} VkCopyCommandTransformInfoQCOM32;

-typedef struct VkPerformanceStreamMarkerInfoINTEL32
+typedef struct VkCopyDescriptorSet32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t marker;
-} VkPerformanceStreamMarkerInfoINTEL32;
+    VkDescriptorSet DECLSPEC_ALIGN(8) srcSet;
+    uint32_t srcBinding;
+    uint32_t srcArrayElement;
+    VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
+    uint32_t dstBinding;
+    uint32_t dstArrayElement;
+    uint32_t descriptorCount;
+} VkCopyDescriptorSet32;

-typedef struct VkVertexInputBindingDescription2EXT32
+typedef struct VkCopyImageInfo232
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t binding;
-    uint32_t stride;
-    VkVertexInputRate inputRate;
-    uint32_t divisor;
-} VkVertexInputBindingDescription2EXT32;
+    VkImage DECLSPEC_ALIGN(8) srcImage;
+    VkImageLayout srcImageLayout;
+    VkImage DECLSPEC_ALIGN(8) dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    PTR32 pRegions;
+} VkCopyImageInfo232;
+typedef VkCopyImageInfo232 VkCopyImageInfo2KHR32;

-typedef struct VkVertexInputAttributeDescription2EXT32
+typedef struct VkCopyImageToBufferInfo232
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t location;
-    uint32_t binding;
-    VkFormat format;
-    uint32_t offset;
-} VkVertexInputAttributeDescription2EXT32;
-
-typedef struct VkShadingRatePaletteNV32
-{
-    uint32_t shadingRatePaletteEntryCount;
-    PTR32 pShadingRatePaletteEntries;
-} VkShadingRatePaletteNV32;
+    VkImage DECLSPEC_ALIGN(8) srcImage;
+    VkImageLayout srcImageLayout;
+    VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
+    uint32_t regionCount;
+    PTR32 pRegions;
+} VkCopyImageToBufferInfo232;
+typedef VkCopyImageToBufferInfo232 VkCopyImageToBufferInfo2KHR32;

typedef struct VkCopyImageToImageInfo32
 {
@@ -2104,19 +2373,6 @@ typedef struct VkCopyImageToImageInfo32
 } VkCopyImageToImageInfo32;
 typedef VkCopyImageToImageInfo32 VkCopyImageToImageInfoEXT32;

-typedef struct VkImageToMemoryCopy32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    PTR32 pHostPointer;
-    uint32_t memoryRowLength;
-    uint32_t memoryImageHeight;
-    VkImageSubresourceLayers imageSubresource;
-    VkOffset3D imageOffset;
-    VkExtent3D imageExtent;
-} VkImageToMemoryCopy32;
-typedef VkImageToMemoryCopy32 VkImageToMemoryCopyEXT32;
-
 typedef struct VkCopyImageToMemoryInfo32
 {
     VkStructureType sType;
@@ -2129,18 +2385,14 @@ typedef struct VkCopyImageToMemoryInfo32
 } VkCopyImageToMemoryInfo32;
 typedef VkCopyImageToMemoryInfo32 VkCopyImageToMemoryInfoEXT32;

-typedef struct VkMemoryToImageCopy32
+typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pHostPointer;
-    uint32_t memoryRowLength;
-    uint32_t memoryImageHeight;
-    VkImageSubresourceLayers imageSubresource;
-    VkOffset3D imageOffset;
-    VkExtent3D imageExtent;
-} VkMemoryToImageCopy32;
-typedef VkMemoryToImageCopy32 VkMemoryToImageCopyEXT32;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
+    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
+    VkCopyAccelerationStructureModeKHR mode;
+} VkCopyMemoryToAccelerationStructureInfoKHR32;

typedef struct VkCopyMemoryToImageInfo32
 {
@@ -2154,459 +2406,370 @@ typedef struct VkCopyMemoryToImageInfo32
 } VkCopyMemoryToImageInfo32;
 typedef VkCopyMemoryToImageInfo32 VkCopyMemoryToImageInfoEXT32;

-typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    PTR32 opaqueCaptureDescriptorData;
-} VkOpaqueCaptureDescriptorDataCreateInfoEXT32;
-
-typedef struct VkAccelerationStructureMotionInfoNV32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    uint32_t maxInstances;
-    VkAccelerationStructureMotionInfoFlagsNV flags;
-} VkAccelerationStructureMotionInfoNV32;
-
-typedef struct VkAccelerationStructureCreateInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkAccelerationStructureCreateFlagsKHR createFlags;
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-    VkDeviceSize DECLSPEC_ALIGN(8) offset;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-    VkAccelerationStructureTypeKHR type;
-    VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
-} VkAccelerationStructureCreateInfoKHR32;
-
-typedef struct VkAccelerationStructureCreateInfoNV32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) compactedSize;
-    VkAccelerationStructureInfoNV32 info;
-} VkAccelerationStructureCreateInfoNV32;
-
-typedef struct VkVideoDecodeUsageInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkVideoDecodeUsageFlagsKHR videoUsageHints;
-} VkVideoDecodeUsageInfoKHR32;
-
-typedef struct VkVideoDecodeH264ProfileInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    StdVideoH264ProfileIdc stdProfileIdc;
-    VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout;
-} VkVideoDecodeH264ProfileInfoKHR32;
-
-typedef struct VkVideoDecodeVP9ProfileInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    StdVideoVP9Profile stdProfile;
-} VkVideoDecodeVP9ProfileInfoKHR32;
-
-typedef struct VkVideoDecodeAV1ProfileInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    StdVideoAV1Profile stdProfile;
-    VkBool32 filmGrainSupport;
-} VkVideoDecodeAV1ProfileInfoKHR32;
-
-typedef struct VkVideoEncodeUsageInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkVideoEncodeUsageFlagsKHR videoUsageHints;
-    VkVideoEncodeContentFlagsKHR videoContentHints;
-    VkVideoEncodeTuningModeKHR tuningMode;
-} VkVideoEncodeUsageInfoKHR32;
-
-typedef struct VkVideoEncodeH264ProfileInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    StdVideoH264ProfileIdc stdProfileIdc;
-} VkVideoEncodeH264ProfileInfoKHR32;
-
-typedef struct VkVideoEncodeAV1ProfileInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    StdVideoAV1Profile stdProfile;
-} VkVideoEncodeAV1ProfileInfoKHR32;
-
-typedef struct VkVideoProfileInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkVideoCodecOperationFlagBitsKHR videoCodecOperation;
-    VkVideoChromaSubsamplingFlagsKHR chromaSubsampling;
-    VkVideoComponentBitDepthFlagsKHR lumaBitDepth;
-    VkVideoComponentBitDepthFlagsKHR chromaBitDepth;
-} VkVideoProfileInfoKHR32;
-
-typedef struct VkDedicatedAllocationBufferCreateInfoNV32
+typedef struct VkCopyMemoryToMicromapInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 dedicatedAllocation;
-} VkDedicatedAllocationBufferCreateInfoNV32;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
+    VkMicromapEXT DECLSPEC_ALIGN(8) dst;
+    VkCopyMicromapModeEXT mode;
+} VkCopyMemoryToMicromapInfoEXT32;

-typedef struct VkExternalMemoryBufferCreateInfo32
+typedef struct VkCopyMicromapInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalMemoryHandleTypeFlags handleTypes;
-} VkExternalMemoryBufferCreateInfo32;
-typedef VkExternalMemoryBufferCreateInfo32 VkExternalMemoryBufferCreateInfoKHR32;
+    VkMicromapEXT DECLSPEC_ALIGN(8) src;
+    VkMicromapEXT DECLSPEC_ALIGN(8) dst;
+    VkCopyMicromapModeEXT mode;
+} VkCopyMicromapInfoEXT32;

-typedef struct VkBufferOpaqueCaptureAddressCreateInfo32
+typedef struct VkCopyMicromapToMemoryInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
-} VkBufferOpaqueCaptureAddressCreateInfo32;
-typedef VkBufferOpaqueCaptureAddressCreateInfo32 VkBufferOpaqueCaptureAddressCreateInfoKHR32;
+    VkMicromapEXT DECLSPEC_ALIGN(8) src;
+    VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
+    VkCopyMicromapModeEXT mode;
+} VkCopyMicromapToMemoryInfoEXT32;

-typedef struct VkBufferDeviceAddressCreateInfoEXT32
+typedef struct VkCopyTensorInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
-} VkBufferDeviceAddressCreateInfoEXT32;
+    VkTensorARM DECLSPEC_ALIGN(8) srcTensor;
+    VkTensorARM DECLSPEC_ALIGN(8) dstTensor;
+    uint32_t regionCount;
+    PTR32 pRegions;
+} VkCopyTensorInfoARM32;

-typedef struct VkVideoProfileListInfoKHR32
+typedef struct VkCuFunctionCreateInfoNVX32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t profileCount;
-    PTR32 pProfiles;
-} VkVideoProfileListInfoKHR32;
+    VkCuModuleNVX DECLSPEC_ALIGN(8) module;
+    PTR32 pName;
+} VkCuFunctionCreateInfoNVX32;

-typedef struct VkBufferCreateInfo32
+typedef struct VkCuLaunchInfoNVX32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBufferCreateFlags flags;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-    VkBufferUsageFlags usage;
-    VkSharingMode sharingMode;
-    uint32_t queueFamilyIndexCount;
-    PTR32 pQueueFamilyIndices;
-} VkBufferCreateInfo32;
+    VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
+    uint32_t gridDimX;
+    uint32_t gridDimY;
+    uint32_t gridDimZ;
+    uint32_t blockDimX;
+    uint32_t blockDimY;
+    uint32_t blockDimZ;
+    uint32_t sharedMemBytes;
+    PTR32 paramCount;
+    PTR32 pParams;
+    PTR32 extraCount;
+    PTR32 pExtras;
+} VkCuLaunchInfoNVX32;

-typedef struct VkBufferViewCreateInfo32
+typedef struct VkCuModuleCreateInfoNVX32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBufferViewCreateFlags flags;
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-    VkFormat format;
-    VkDeviceSize DECLSPEC_ALIGN(8) offset;
-    VkDeviceSize DECLSPEC_ALIGN(8) range;
-} VkBufferViewCreateInfo32;
+    PTR32 dataSize;
+    PTR32 pData;
+} VkCuModuleCreateInfoNVX32;

-typedef struct VkDataGraphProcessingEngineCreateInfoARM32
+typedef struct VkCuModuleTexturingModeCreateInfoNVX32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t processingEngineCount;
-    PTR32 pProcessingEngines;
-} VkDataGraphProcessingEngineCreateInfoARM32;
+    VkBool32 use64bitTexturing;
+} VkCuModuleTexturingModeCreateInfoNVX32;

-typedef struct VkCommandPoolCreateInfo32
+typedef struct VkDataGraphPipelineCompilerControlCreateInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkCommandPoolCreateFlags flags;
-    uint32_t queueFamilyIndex;
-} VkCommandPoolCreateInfo32;
-
-typedef struct VkPipelineCreationFeedback32
-{
-    VkPipelineCreationFeedbackFlags flags;
-    uint64_t DECLSPEC_ALIGN(8) duration;
-} VkPipelineCreationFeedback32;
-typedef VkPipelineCreationFeedback32 VkPipelineCreationFeedbackEXT32;
-
-typedef struct VkSpecializationMapEntry32
-{
-    uint32_t constantID;
-    uint32_t offset;
-    PTR32 size;
-} VkSpecializationMapEntry32;
+    PTR32 pVendorOptions;
+} VkDataGraphPipelineCompilerControlCreateInfoARM32;

-typedef struct VkSpecializationInfo32
+typedef struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32
 {
-    uint32_t mapEntryCount;
-    PTR32 pMapEntries;
-    PTR32 dataSize;
-    PTR32 pData;
-} VkSpecializationInfo32;
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t dimension;
+    uint32_t zeroCount;
+    uint32_t groupSize;
+} VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32;

-typedef struct VkShaderModuleCreateInfo32
+typedef struct VkDataGraphPipelineCreateInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderModuleCreateFlags flags;
-    PTR32 codeSize;
-    PTR32 pCode;
-} VkShaderModuleCreateInfo32;
+    VkPipelineCreateFlags2KHR flags;
+    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
+    uint32_t resourceInfoCount;
+    PTR32 pResourceInfos;
+} VkDataGraphPipelineCreateInfoARM32;

-typedef struct VkShaderModuleValidationCacheCreateInfoEXT32
+typedef struct VkDataGraphPipelineDispatchInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
-} VkShaderModuleValidationCacheCreateInfoEXT32;
+    VkDataGraphPipelineDispatchFlagsARM DECLSPEC_ALIGN(8) flags;
+} VkDataGraphPipelineDispatchInfoARM32;

-typedef struct VkDebugUtilsObjectNameInfoEXT32
+typedef struct VkDataGraphPipelineIdentifierCreateInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkObjectType objectType;
-    uint64_t DECLSPEC_ALIGN(8) objectHandle;
-    PTR32 pObjectName;
-} VkDebugUtilsObjectNameInfoEXT32;
+    uint32_t identifierSize;
+    PTR32 pIdentifier;
+} VkDataGraphPipelineIdentifierCreateInfoARM32;

-typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32
+typedef struct VkDataGraphPipelineInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t requiredSubgroupSize;
-} VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32;
-typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT32;
-typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkShaderRequiredSubgroupSizeCreateInfoEXT32;
+    VkPipeline DECLSPEC_ALIGN(8) dataGraphPipeline;
+} VkDataGraphPipelineInfoARM32;

-typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT32
+typedef struct VkDataGraphPipelinePropertyQueryResultARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t identifierSize;
-    PTR32 pIdentifier;
-} VkPipelineShaderStageModuleIdentifierCreateInfoEXT32;
+    VkDataGraphPipelinePropertyARM property;
+    VkBool32 isText;
+    PTR32 dataSize;
+    PTR32 pData;
+} VkDataGraphPipelinePropertyQueryResultARM32;

-typedef struct VkPipelineRobustnessCreateInfo32
+typedef struct VkDataGraphPipelineSessionBindPointRequirementARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineRobustnessBufferBehavior storageBuffers;
-    VkPipelineRobustnessBufferBehavior uniformBuffers;
-    VkPipelineRobustnessBufferBehavior vertexInputs;
-    VkPipelineRobustnessImageBehavior images;
-} VkPipelineRobustnessCreateInfo32;
-typedef VkPipelineRobustnessCreateInfo32 VkPipelineRobustnessCreateInfoEXT32;
+    VkDataGraphPipelineSessionBindPointARM bindPoint;
+    VkDataGraphPipelineSessionBindPointTypeARM bindPointType;
+    uint32_t numObjects;
+} VkDataGraphPipelineSessionBindPointRequirementARM32;

-typedef struct VkPipelineShaderStageCreateInfo32
+typedef struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineShaderStageCreateFlags flags;
-    VkShaderStageFlagBits stage;
-    VkShaderModule DECLSPEC_ALIGN(8) module;
-    PTR32 pName;
-    PTR32 pSpecializationInfo;
-} VkPipelineShaderStageCreateInfo32;
+    VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session;
+} VkDataGraphPipelineSessionBindPointRequirementsInfoARM32;

-typedef struct VkComputePipelineIndirectBufferInfoNV32
+typedef struct VkDataGraphPipelineSessionCreateInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-    VkDeviceAddress DECLSPEC_ALIGN(8) pipelineDeviceAddressCaptureReplay;
-} VkComputePipelineIndirectBufferInfoNV32;
+    VkDataGraphPipelineSessionCreateFlagsARM DECLSPEC_ALIGN(8) flags;
+    VkPipeline DECLSPEC_ALIGN(8) dataGraphPipeline;
+} VkDataGraphPipelineSessionCreateInfoARM32;

-typedef struct VkPipelineCreateFlags2CreateInfo32
+typedef struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineCreateFlags2 DECLSPEC_ALIGN(8) flags;
-} VkPipelineCreateFlags2CreateInfo32;
-typedef VkPipelineCreateFlags2CreateInfo32 VkPipelineCreateFlags2CreateInfoKHR32;
+    VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session;
+    VkDataGraphPipelineSessionBindPointARM bindPoint;
+    uint32_t objectIndex;
+} VkDataGraphPipelineSessionMemoryRequirementsInfoARM32;

-typedef struct VkPipelineBinaryInfoKHR32
+typedef struct VkDataGraphPipelineShaderModuleCreateInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t binaryCount;
-    PTR32 pPipelineBinaries;
-} VkPipelineBinaryInfoKHR32;
+    VkShaderModule DECLSPEC_ALIGN(8) module;
+    PTR32 pName;
+    PTR32 pSpecializationInfo;
+    uint32_t constantCount;
+    PTR32 pConstants;
+} VkDataGraphPipelineShaderModuleCreateInfoARM32;

-typedef struct VkPipelineCreationFeedbackCreateInfo32
+typedef struct VkDataGraphProcessingEngineCreateInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pPipelineCreationFeedback;
-    uint32_t pipelineStageCreationFeedbackCount;
-    PTR32 pPipelineStageCreationFeedbacks;
-} VkPipelineCreationFeedbackCreateInfo32;
-typedef VkPipelineCreationFeedbackCreateInfo32 VkPipelineCreationFeedbackCreateInfoEXT32;
+    uint32_t processingEngineCount;
+    PTR32 pProcessingEngines;
+} VkDataGraphProcessingEngineCreateInfoARM32;

-typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI32
+typedef struct VkDebugMarkerMarkerInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkRenderPass DECLSPEC_ALIGN(8) renderPass;
-    uint32_t subpass;
-} VkSubpassShadingPipelineCreateInfoHUAWEI32;
+    PTR32 pMarkerName;
+    float color[4];
+} VkDebugMarkerMarkerInfoEXT32;

-typedef struct VkPipelineCompilerControlCreateInfoAMD32
+typedef struct VkDebugMarkerObjectNameInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineCompilerControlFlagsAMD compilerControlFlags;
-} VkPipelineCompilerControlCreateInfoAMD32;
+    VkDebugReportObjectTypeEXT objectType;
+    uint64_t DECLSPEC_ALIGN(8) object;
+    PTR32 pObjectName;
+} VkDebugMarkerObjectNameInfoEXT32;

-typedef struct VkComputePipelineCreateInfo32
+typedef struct VkDebugMarkerObjectTagInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineCreateFlags flags;
-    VkPipelineShaderStageCreateInfo32 DECLSPEC_ALIGN(8) stage;
-    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
-    VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
-    int32_t basePipelineIndex;
-} VkComputePipelineCreateInfo32;
+    VkDebugReportObjectTypeEXT objectType;
+    uint64_t DECLSPEC_ALIGN(8) object;
+    uint64_t DECLSPEC_ALIGN(8) tagName;
+    PTR32 tagSize;
+    PTR32 pTag;
+} VkDebugMarkerObjectTagInfoEXT32;

-typedef struct VkCuFunctionCreateInfoNVX32
+typedef struct VkDebugReportCallbackCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkCuModuleNVX DECLSPEC_ALIGN(8) module;
-    PTR32 pName;
-} VkCuFunctionCreateInfoNVX32;
+    VkDebugReportFlagsEXT flags;
+    PTR32 pfnCallback;
+    PTR32 pUserData;
+} VkDebugReportCallbackCreateInfoEXT32;

-typedef struct VkCuModuleTexturingModeCreateInfoNVX32
+typedef struct VkDebugUtilsMessengerCallbackDataEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 use64bitTexturing;
-} VkCuModuleTexturingModeCreateInfoNVX32;
+    VkDebugUtilsMessengerCallbackDataFlagsEXT flags;
+    PTR32 pMessageIdName;
+    int32_t messageIdNumber;
+    PTR32 pMessage;
+    uint32_t queueLabelCount;
+    PTR32 pQueueLabels;
+    uint32_t cmdBufLabelCount;
+    PTR32 pCmdBufLabels;
+    uint32_t objectCount;
+    PTR32 pObjects;
+} VkDebugUtilsMessengerCallbackDataEXT32;

-typedef struct VkCuModuleCreateInfoNVX32
+typedef struct VkDebugUtilsMessengerCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 dataSize;
-    PTR32 pData;
-} VkCuModuleCreateInfoNVX32;
+    VkDebugUtilsMessengerCreateFlagsEXT flags;
+    VkDebugUtilsMessageSeverityFlagsEXT messageSeverity;
+    VkDebugUtilsMessageTypeFlagsEXT messageType;
+    PTR32 pfnUserCallback;
+    PTR32 pUserData;
+} VkDebugUtilsMessengerCreateInfoEXT32;

-typedef struct VkDataGraphPipelineSessionCreateInfoARM32
+typedef struct VkDebugUtilsObjectTagInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDataGraphPipelineSessionCreateFlagsARM DECLSPEC_ALIGN(8) flags;
-    VkPipeline DECLSPEC_ALIGN(8) dataGraphPipeline;
-} VkDataGraphPipelineSessionCreateInfoARM32;
+    VkObjectType objectType;
+    uint64_t DECLSPEC_ALIGN(8) objectHandle;
+    uint64_t DECLSPEC_ALIGN(8) tagName;
+    PTR32 tagSize;
+    PTR32 pTag;
+} VkDebugUtilsObjectTagInfoEXT32;

-typedef struct VkTensorDescriptionARM32
+typedef struct VkDecompressMemoryRegionNV32
+{
+    VkDeviceAddress DECLSPEC_ALIGN(8) srcAddress;
+    VkDeviceAddress DECLSPEC_ALIGN(8) dstAddress;
+    VkDeviceSize DECLSPEC_ALIGN(8) compressedSize;
+    VkDeviceSize DECLSPEC_ALIGN(8) decompressedSize;
+    VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethod;
+} VkDecompressMemoryRegionNV32;
+
+typedef struct VkDedicatedAllocationBufferCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkTensorTilingARM tiling;
-    VkFormat format;
-    uint32_t dimensionCount;
-    PTR32 pDimensions;
-    PTR32 pStrides;
-    VkTensorUsageFlagsARM DECLSPEC_ALIGN(8) usage;
-} VkTensorDescriptionARM32;
+    VkBool32 dedicatedAllocation;
+} VkDedicatedAllocationBufferCreateInfoNV32;

-typedef struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32
+typedef struct VkDedicatedAllocationImageCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t dimension;
-    uint32_t zeroCount;
-    uint32_t groupSize;
-} VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32;
+    VkBool32 dedicatedAllocation;
+} VkDedicatedAllocationImageCreateInfoNV32;

-typedef struct VkDataGraphPipelineConstantARM32
+typedef struct VkDedicatedAllocationMemoryAllocateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t id;
-    PTR32 pConstantData;
-} VkDataGraphPipelineConstantARM32;
+    VkImage DECLSPEC_ALIGN(8) image;
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+} VkDedicatedAllocationMemoryAllocateInfoNV32;

-typedef struct VkDataGraphPipelineResourceInfoARM32
+typedef struct VkDependencyInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t descriptorSet;
-    uint32_t binding;
-    uint32_t arrayElement;
-} VkDataGraphPipelineResourceInfoARM32;
+    VkDependencyFlags dependencyFlags;
+    uint32_t memoryBarrierCount;
+    PTR32 pMemoryBarriers;
+    uint32_t bufferMemoryBarrierCount;
+    PTR32 pBufferMemoryBarriers;
+    uint32_t imageMemoryBarrierCount;
+    PTR32 pImageMemoryBarriers;
+} VkDependencyInfo32;
+typedef VkDependencyInfo32 VkDependencyInfoKHR32;

-typedef struct VkDataGraphPipelineCompilerControlCreateInfoARM32
+typedef struct VkDepthBiasInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pVendorOptions;
-} VkDataGraphPipelineCompilerControlCreateInfoARM32;
+    float depthBiasConstantFactor;
+    float depthBiasClamp;
+    float depthBiasSlopeFactor;
+} VkDepthBiasInfoEXT32;

-typedef struct VkDataGraphPipelineShaderModuleCreateInfoARM32
+typedef struct VkDepthBiasRepresentationInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderModule DECLSPEC_ALIGN(8) module;
-    PTR32 pName;
-    PTR32 pSpecializationInfo;
-    uint32_t constantCount;
-    PTR32 pConstants;
-} VkDataGraphPipelineShaderModuleCreateInfoARM32;
+    VkDepthBiasRepresentationEXT depthBiasRepresentation;
+    VkBool32 depthBiasExact;
+} VkDepthBiasRepresentationInfoEXT32;

-typedef struct VkDataGraphPipelineIdentifierCreateInfoARM32
+typedef struct VkDescriptorBufferBindingInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t identifierSize;
-    PTR32 pIdentifier;
-} VkDataGraphPipelineIdentifierCreateInfoARM32;
+    VkDeviceAddress DECLSPEC_ALIGN(8) address;
+    VkBufferUsageFlags usage;
+} VkDescriptorBufferBindingInfoEXT32;

-typedef struct VkDataGraphPipelineCreateInfoARM32
+typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineCreateFlags2KHR flags;
-    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
-    uint32_t resourceInfoCount;
-    PTR32 pResourceInfos;
-} VkDataGraphPipelineCreateInfoARM32;
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+} VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32;

-typedef struct VkDebugReportCallbackCreateInfoEXT32
+typedef struct VkDescriptorGetInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDebugReportFlagsEXT flags;
-    PTR32 pfnCallback;
-    PTR32 pUserData;
-} VkDebugReportCallbackCreateInfoEXT32;
+    VkDescriptorType type;
+    VkDescriptorDataEXT32 DECLSPEC_ALIGN(8) data;
+} VkDescriptorGetInfoEXT32;

-typedef struct VkDebugUtilsMessengerCreateInfoEXT32
+typedef struct VkDescriptorGetTensorInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDebugUtilsMessengerCreateFlagsEXT flags;
-    VkDebugUtilsMessageSeverityFlagsEXT messageSeverity;
-    VkDebugUtilsMessageTypeFlagsEXT messageType;
-    PTR32 pfnUserCallback;
-    PTR32 pUserData;
-} VkDebugUtilsMessengerCreateInfoEXT32;
+    VkTensorViewARM DECLSPEC_ALIGN(8) tensorView;
+} VkDescriptorGetTensorInfoARM32;

-typedef struct VkMutableDescriptorTypeListEXT32
+typedef struct VkDescriptorPoolCreateInfo32
 {
-    uint32_t descriptorTypeCount;
-    PTR32 pDescriptorTypes;
-} VkMutableDescriptorTypeListEXT32;
-typedef VkMutableDescriptorTypeListEXT32 VkMutableDescriptorTypeListVALVE32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkDescriptorPoolCreateFlags flags;
+    uint32_t maxSets;
+    uint32_t poolSizeCount;
+    PTR32 pPoolSizes;
+} VkDescriptorPoolCreateInfo32;

typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo32
 {
@@ -2616,33 +2779,22 @@ typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo32
 } VkDescriptorPoolInlineUniformBlockCreateInfo32;
 typedef VkDescriptorPoolInlineUniformBlockCreateInfo32 VkDescriptorPoolInlineUniformBlockCreateInfoEXT32;

-typedef struct VkMutableDescriptorTypeCreateInfoEXT32
+typedef struct VkDescriptorSetAllocateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t mutableDescriptorTypeListCount;
-    PTR32 pMutableDescriptorTypeLists;
-} VkMutableDescriptorTypeCreateInfoEXT32;
-typedef VkMutableDescriptorTypeCreateInfoEXT32 VkMutableDescriptorTypeCreateInfoVALVE32;
+    VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
+    uint32_t descriptorSetCount;
+    PTR32 pSetLayouts;
+} VkDescriptorSetAllocateInfo32;

-typedef struct VkDescriptorPoolCreateInfo32
+typedef struct VkDescriptorSetBindingReferenceVALVE32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDescriptorPoolCreateFlags flags;
-    uint32_t maxSets;
-    uint32_t poolSizeCount;
-    PTR32 pPoolSizes;
-} VkDescriptorPoolCreateInfo32;
-
-typedef struct VkDescriptorSetLayoutBinding32
-{
+    VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
     uint32_t binding;
-    VkDescriptorType descriptorType;
-    uint32_t descriptorCount;
-    VkShaderStageFlags stageFlags;
-    PTR32 pImmutableSamplers;
-} VkDescriptorSetLayoutBinding32;
+} VkDescriptorSetBindingReferenceVALVE32;

typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo32
 {
@@ -2662,16 +2814,38 @@ typedef struct VkDescriptorSetLayoutCreateInfo32
     PTR32 pBindings;
 } VkDescriptorSetLayoutCreateInfo32;

-typedef struct VkDescriptorUpdateTemplateEntry32
+typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE32
 {
-    uint32_t dstBinding;
-    uint32_t dstArrayElement;
-    uint32_t descriptorCount;
-    VkDescriptorType descriptorType;
-    PTR32 offset;
-    PTR32 stride;
-} VkDescriptorUpdateTemplateEntry32;
-typedef VkDescriptorUpdateTemplateEntry32 VkDescriptorUpdateTemplateEntryKHR32;
+    VkStructureType sType;
+    PTR32 pNext;
+    PTR32 descriptorOffset;
+    uint32_t descriptorSize;
+} VkDescriptorSetLayoutHostMappingInfoVALVE32;
+
+typedef struct VkDescriptorSetLayoutSupport32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 supported;
+} VkDescriptorSetLayoutSupport32;
+typedef VkDescriptorSetLayoutSupport32 VkDescriptorSetLayoutSupportKHR32;
+
+typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t descriptorSetCount;
+    PTR32 pDescriptorCounts;
+} VkDescriptorSetVariableDescriptorCountAllocateInfo32;
+typedef VkDescriptorSetVariableDescriptorCountAllocateInfo32 VkDescriptorSetVariableDescriptorCountAllocateInfoEXT32;
+
+typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t maxVariableDescriptorCount;
+} VkDescriptorSetVariableDescriptorCountLayoutSupport32;
+typedef VkDescriptorSetVariableDescriptorCountLayoutSupport32 VkDescriptorSetVariableDescriptorCountLayoutSupportEXT32;

typedef struct VkDescriptorUpdateTemplateCreateInfo32
 {
@@ -2688,6036 +2862,5957 @@ typedef struct VkDescriptorUpdateTemplateCreateInfo32
 } VkDescriptorUpdateTemplateCreateInfo32;
 typedef VkDescriptorUpdateTemplateCreateInfo32 VkDescriptorUpdateTemplateCreateInfoKHR32;

-typedef struct VkDeviceQueueGlobalPriorityCreateInfo32
+typedef struct VkDeviceAddressBindingCallbackDataEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkQueueGlobalPriority globalPriority;
-} VkDeviceQueueGlobalPriorityCreateInfo32;
-typedef VkDeviceQueueGlobalPriorityCreateInfo32 VkDeviceQueueGlobalPriorityCreateInfoKHR32;
-typedef VkDeviceQueueGlobalPriorityCreateInfo32 VkDeviceQueueGlobalPriorityCreateInfoEXT32;
+    VkDeviceAddressBindingFlagsEXT flags;
+    VkDeviceAddress DECLSPEC_ALIGN(8) baseAddress;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+    VkDeviceAddressBindingTypeEXT bindingType;
+} VkDeviceAddressBindingCallbackDataEXT32;
+
+typedef struct VkDeviceBufferMemoryRequirements32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    PTR32 pCreateInfo;
+} VkDeviceBufferMemoryRequirements32;
+typedef VkDeviceBufferMemoryRequirements32 VkDeviceBufferMemoryRequirementsKHR32;
+
+typedef struct VkDeviceCreateInfo32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkDeviceCreateFlags flags;
+    uint32_t queueCreateInfoCount;
+    PTR32 pQueueCreateInfos;
+    uint32_t enabledLayerCount;
+    PTR32 ppEnabledLayerNames;
+    uint32_t enabledExtensionCount;
+    PTR32 ppEnabledExtensionNames;
+    PTR32 pEnabledFeatures;
+} VkDeviceCreateInfo32;
+
+typedef struct VkDeviceDiagnosticsConfigCreateInfoNV32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkDeviceDiagnosticsConfigFlagsNV flags;
+} VkDeviceDiagnosticsConfigCreateInfoNV32;
+
+typedef struct VkDeviceFaultCountsEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t addressInfoCount;
+    uint32_t vendorInfoCount;
+    VkDeviceSize DECLSPEC_ALIGN(8) vendorBinarySize;
+} VkDeviceFaultCountsEXT32;
+
+typedef struct VkDeviceFaultInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    PTR32 pAddressInfos;
+    PTR32 pVendorInfos;
+    PTR32 pVendorBinaryData;
+} VkDeviceFaultInfoEXT32;
+
+typedef struct VkDeviceGroupBindSparseInfo32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t resourceDeviceIndex;
+    uint32_t memoryDeviceIndex;
+} VkDeviceGroupBindSparseInfo32;
+typedef VkDeviceGroupBindSparseInfo32 VkDeviceGroupBindSparseInfoKHR32;
+
+typedef struct VkDeviceGroupCommandBufferBeginInfo32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t deviceMask;
+} VkDeviceGroupCommandBufferBeginInfo32;
+typedef VkDeviceGroupCommandBufferBeginInfo32 VkDeviceGroupCommandBufferBeginInfoKHR32;
+
+typedef struct VkDeviceGroupDeviceCreateInfo32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t physicalDeviceCount;
+    PTR32 pPhysicalDevices;
+} VkDeviceGroupDeviceCreateInfo32;
+typedef VkDeviceGroupDeviceCreateInfo32 VkDeviceGroupDeviceCreateInfoKHR32;
+
+typedef struct VkDeviceGroupPresentCapabilitiesKHR32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
+    VkDeviceGroupPresentModeFlagsKHR modes;
+} VkDeviceGroupPresentCapabilitiesKHR32;

-typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM32
+typedef struct VkDeviceGroupPresentInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t shaderCoreCount;
-} VkDeviceQueueShaderCoreControlCreateInfoARM32;
+    uint32_t swapchainCount;
+    PTR32 pDeviceMasks;
+    VkDeviceGroupPresentModeFlagBitsKHR mode;
+} VkDeviceGroupPresentInfoKHR32;

-typedef struct VkDeviceQueueCreateInfo32
+typedef struct VkDeviceGroupRenderPassBeginInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceQueueCreateFlags flags;
-    uint32_t queueFamilyIndex;
-    uint32_t queueCount;
-    PTR32 pQueuePriorities;
-} VkDeviceQueueCreateInfo32;
+    uint32_t deviceMask;
+    uint32_t deviceRenderAreaCount;
+    PTR32 pDeviceRenderAreas;
+} VkDeviceGroupRenderPassBeginInfo32;
+typedef VkDeviceGroupRenderPassBeginInfo32 VkDeviceGroupRenderPassBeginInfoKHR32;

-typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32
+typedef struct VkDeviceGroupSubmitInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 deviceGeneratedCommands;
-} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32;
+    uint32_t waitSemaphoreCount;
+    PTR32 pWaitSemaphoreDeviceIndices;
+    uint32_t commandBufferCount;
+    PTR32 pCommandBufferDeviceMasks;
+    uint32_t signalSemaphoreCount;
+    PTR32 pSignalSemaphoreDeviceIndices;
+} VkDeviceGroupSubmitInfo32;
+typedef VkDeviceGroupSubmitInfo32 VkDeviceGroupSubmitInfoKHR32;

-typedef struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32
+typedef struct VkDeviceGroupSwapchainCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 deviceGeneratedCompute;
-    VkBool32 deviceGeneratedComputePipelines;
-    VkBool32 deviceGeneratedComputeCaptureReplay;
-} VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32;
+    VkDeviceGroupPresentModeFlagsKHR modes;
+} VkDeviceGroupSwapchainCreateInfoKHR32;

-typedef struct VkDevicePrivateDataCreateInfo32
+typedef struct VkDeviceImageMemoryRequirements32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t privateDataSlotRequestCount;
-} VkDevicePrivateDataCreateInfo32;
-typedef VkDevicePrivateDataCreateInfo32 VkDevicePrivateDataCreateInfoEXT32;
+    PTR32 pCreateInfo;
+    VkImageAspectFlagBits planeAspect;
+} VkDeviceImageMemoryRequirements32;
+typedef VkDeviceImageMemoryRequirements32 VkDeviceImageMemoryRequirementsKHR32;

-typedef struct VkPhysicalDevicePrivateDataFeatures32
+typedef struct VkDeviceImageSubresourceInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 privateData;
-} VkPhysicalDevicePrivateDataFeatures32;
-typedef VkPhysicalDevicePrivateDataFeatures32 VkPhysicalDevicePrivateDataFeaturesEXT32;
+    PTR32 pCreateInfo;
+    PTR32 pSubresource;
+} VkDeviceImageSubresourceInfo32;
+typedef VkDeviceImageSubresourceInfo32 VkDeviceImageSubresourceInfoKHR32;

-typedef struct VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32
+typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 clusterAccelerationStructure;
-} VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32;
+    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
+} VkDeviceMemoryOpaqueCaptureAddressInfo32;
+typedef VkDeviceMemoryOpaqueCaptureAddressInfo32 VkDeviceMemoryOpaqueCaptureAddressInfoKHR32;

-typedef struct VkPhysicalDeviceFeatures232
+typedef struct VkDeviceMemoryOverallocationCreateInfoAMD32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPhysicalDeviceFeatures features;
-} VkPhysicalDeviceFeatures232;
-typedef VkPhysicalDeviceFeatures232 VkPhysicalDeviceFeatures2KHR32;
+    VkMemoryOverallocationBehaviorAMD overallocationBehavior;
+} VkDeviceMemoryOverallocationCreateInfoAMD32;

-typedef struct VkPhysicalDeviceVariablePointersFeatures32
+typedef struct VkDevicePipelineBinaryInternalCacheControlKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 variablePointersStorageBuffer;
-    VkBool32 variablePointers;
-} VkPhysicalDeviceVariablePointersFeatures32;
-typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointersFeaturesKHR32;
-typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeaturesKHR32;
-typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeatures32;
+    VkBool32 disableInternalCache;
+} VkDevicePipelineBinaryInternalCacheControlKHR32;

-typedef struct VkPhysicalDeviceMultiviewFeatures32
+typedef struct VkDevicePrivateDataCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 multiview;
-    VkBool32 multiviewGeometryShader;
-    VkBool32 multiviewTessellationShader;
-} VkPhysicalDeviceMultiviewFeatures32;
-typedef VkPhysicalDeviceMultiviewFeatures32 VkPhysicalDeviceMultiviewFeaturesKHR32;
+    uint32_t privateDataSlotRequestCount;
+} VkDevicePrivateDataCreateInfo32;
+typedef VkDevicePrivateDataCreateInfo32 VkDevicePrivateDataCreateInfoEXT32;

-typedef struct VkDeviceGroupDeviceCreateInfo32
+typedef struct VkDeviceQueueGlobalPriorityCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t physicalDeviceCount;
-    PTR32 pPhysicalDevices;
-} VkDeviceGroupDeviceCreateInfo32;
-typedef VkDeviceGroupDeviceCreateInfo32 VkDeviceGroupDeviceCreateInfoKHR32;
+    VkQueueGlobalPriority globalPriority;
+} VkDeviceQueueGlobalPriorityCreateInfo32;
+typedef VkDeviceQueueGlobalPriorityCreateInfo32 VkDeviceQueueGlobalPriorityCreateInfoKHR32;
+typedef VkDeviceQueueGlobalPriorityCreateInfo32 VkDeviceQueueGlobalPriorityCreateInfoEXT32;

-typedef struct VkPhysicalDevicePresentIdFeaturesKHR32
+typedef struct VkDeviceQueueInfo232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 presentId;
-} VkPhysicalDevicePresentIdFeaturesKHR32;
+    VkDeviceQueueCreateFlags flags;
+    uint32_t queueFamilyIndex;
+    uint32_t queueIndex;
+} VkDeviceQueueInfo232;

-typedef struct VkPhysicalDevicePresentId2FeaturesKHR32
+typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 presentId2;
-} VkPhysicalDevicePresentId2FeaturesKHR32;
+    uint32_t shaderCoreCount;
+} VkDeviceQueueShaderCoreControlCreateInfoARM32;

-typedef struct VkPhysicalDevicePresentWaitFeaturesKHR32
+typedef struct VkDeviceTensorMemoryRequirementsARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 presentWait;
-} VkPhysicalDevicePresentWaitFeaturesKHR32;
+    PTR32 pCreateInfo;
+} VkDeviceTensorMemoryRequirementsARM32;

-typedef struct VkPhysicalDevicePresentWait2FeaturesKHR32
+typedef struct VkDispatchTileInfoQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 presentWait2;
-} VkPhysicalDevicePresentWait2FeaturesKHR32;
+} VkDispatchTileInfoQCOM32;

-typedef struct VkPhysicalDevice16BitStorageFeatures32
+typedef struct VkEventCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 storageBuffer16BitAccess;
-    VkBool32 uniformAndStorageBuffer16BitAccess;
-    VkBool32 storagePushConstant16;
-    VkBool32 storageInputOutput16;
-} VkPhysicalDevice16BitStorageFeatures32;
-typedef VkPhysicalDevice16BitStorageFeatures32 VkPhysicalDevice16BitStorageFeaturesKHR32;
+    VkEventCreateFlags flags;
+} VkEventCreateInfo32;

-typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32
+typedef struct VkExportFenceCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderSubgroupExtendedTypes;
-} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32;
-typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR32;
+    VkExternalFenceHandleTypeFlags handleTypes;
+} VkExportFenceCreateInfo32;
+typedef VkExportFenceCreateInfo32 VkExportFenceCreateInfoKHR32;

-typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures32
+typedef struct VkExportMemoryAllocateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 samplerYcbcrConversion;
-} VkPhysicalDeviceSamplerYcbcrConversionFeatures32;
-typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures32 VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR32;
+    VkExternalMemoryHandleTypeFlags handleTypes;
+} VkExportMemoryAllocateInfo32;
+typedef VkExportMemoryAllocateInfo32 VkExportMemoryAllocateInfoKHR32;

-typedef struct VkPhysicalDeviceProtectedMemoryFeatures32
+typedef struct VkExportMemoryWin32HandleInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 protectedMemory;
-} VkPhysicalDeviceProtectedMemoryFeatures32;
+    PTR32 pAttributes;
+    DWORD dwAccess;
+    LPCWSTR name;
+} VkExportMemoryWin32HandleInfoKHR32;

-typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32
+typedef struct VkExportSemaphoreCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 advancedBlendCoherentOperations;
-} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32;
+    VkExternalSemaphoreHandleTypeFlags handleTypes;
+} VkExportSemaphoreCreateInfo32;
+typedef VkExportSemaphoreCreateInfo32 VkExportSemaphoreCreateInfoKHR32;

-typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT32
+typedef struct VkExternalBufferProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 multiDraw;
-} VkPhysicalDeviceMultiDrawFeaturesEXT32;
+    VkExternalMemoryProperties externalMemoryProperties;
+} VkExternalBufferProperties32;
+typedef VkExternalBufferProperties32 VkExternalBufferPropertiesKHR32;

-typedef struct VkPhysicalDeviceInlineUniformBlockFeatures32
+typedef struct VkExternalFenceProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 inlineUniformBlock;
-    VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
-} VkPhysicalDeviceInlineUniformBlockFeatures32;
-typedef VkPhysicalDeviceInlineUniformBlockFeatures32 VkPhysicalDeviceInlineUniformBlockFeaturesEXT32;
+    VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
+    VkExternalFenceHandleTypeFlags compatibleHandleTypes;
+    VkExternalFenceFeatureFlags externalFenceFeatures;
+} VkExternalFenceProperties32;
+typedef VkExternalFenceProperties32 VkExternalFencePropertiesKHR32;

-typedef struct VkPhysicalDeviceMaintenance4Features32
+typedef struct VkExternalImageFormatProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 maintenance4;
-} VkPhysicalDeviceMaintenance4Features32;
-typedef VkPhysicalDeviceMaintenance4Features32 VkPhysicalDeviceMaintenance4FeaturesKHR32;
+    VkExternalMemoryProperties externalMemoryProperties;
+} VkExternalImageFormatProperties32;
+typedef VkExternalImageFormatProperties32 VkExternalImageFormatPropertiesKHR32;

-typedef struct VkPhysicalDeviceMaintenance5Features32
+typedef struct VkExternalMemoryAcquireUnmodifiedEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 maintenance5;
-} VkPhysicalDeviceMaintenance5Features32;
-typedef VkPhysicalDeviceMaintenance5Features32 VkPhysicalDeviceMaintenance5FeaturesKHR32;
+    VkBool32 acquireUnmodifiedMemory;
+} VkExternalMemoryAcquireUnmodifiedEXT32;

-typedef struct VkPhysicalDeviceMaintenance6Features32
+typedef struct VkExternalMemoryBufferCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 maintenance6;
-} VkPhysicalDeviceMaintenance6Features32;
-typedef VkPhysicalDeviceMaintenance6Features32 VkPhysicalDeviceMaintenance6FeaturesKHR32;
+    VkExternalMemoryHandleTypeFlags handleTypes;
+} VkExternalMemoryBufferCreateInfo32;
+typedef VkExternalMemoryBufferCreateInfo32 VkExternalMemoryBufferCreateInfoKHR32;

-typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR32
+typedef struct VkExternalMemoryImageCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 maintenance8;
-} VkPhysicalDeviceMaintenance8FeaturesKHR32;
+    VkExternalMemoryHandleTypeFlags handleTypes;
+} VkExternalMemoryImageCreateInfo32;
+typedef VkExternalMemoryImageCreateInfo32 VkExternalMemoryImageCreateInfoKHR32;

-typedef struct VkPhysicalDeviceMaintenance9FeaturesKHR32
+typedef struct VkExternalMemoryTensorCreateInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 maintenance9;
-} VkPhysicalDeviceMaintenance9FeaturesKHR32;
+    VkExternalMemoryHandleTypeFlags handleTypes;
+} VkExternalMemoryTensorCreateInfoARM32;

-typedef struct VkPhysicalDeviceShaderDrawParametersFeatures32
+typedef struct VkExternalSemaphoreProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderDrawParameters;
-} VkPhysicalDeviceShaderDrawParametersFeatures32;
-typedef VkPhysicalDeviceShaderDrawParametersFeatures32 VkPhysicalDeviceShaderDrawParameterFeatures32;
+    VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
+    VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
+    VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
+} VkExternalSemaphoreProperties32;
+typedef VkExternalSemaphoreProperties32 VkExternalSemaphorePropertiesKHR32;

-typedef struct VkPhysicalDeviceShaderFloat16Int8Features32
+typedef struct VkExternalTensorPropertiesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderFloat16;
-    VkBool32 shaderInt8;
-} VkPhysicalDeviceShaderFloat16Int8Features32;
-typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceShaderFloat16Int8FeaturesKHR32;
-typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceFloat16Int8FeaturesKHR32;
+    VkExternalMemoryProperties externalMemoryProperties;
+} VkExternalTensorPropertiesARM32;

-typedef struct VkPhysicalDeviceHostQueryResetFeatures32
+typedef struct VkFenceCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 hostQueryReset;
-} VkPhysicalDeviceHostQueryResetFeatures32;
-typedef VkPhysicalDeviceHostQueryResetFeatures32 VkPhysicalDeviceHostQueryResetFeaturesEXT32;
+    VkFenceCreateFlags flags;
+} VkFenceCreateInfo32;

-typedef struct VkPhysicalDeviceGlobalPriorityQueryFeatures32
+typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 globalPriorityQuery;
-} VkPhysicalDeviceGlobalPriorityQueryFeatures32;
-typedef VkPhysicalDeviceGlobalPriorityQueryFeatures32 VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32;
-typedef VkPhysicalDeviceGlobalPriorityQueryFeatures32 VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT32;
+    VkBool32 filterCubic;
+    VkBool32 filterCubicMinmax;
+} VkFilterCubicImageViewImageFormatPropertiesEXT32;

-typedef struct VkPhysicalDeviceDescriptorIndexingFeatures32
+typedef struct VkFormatProperties232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderInputAttachmentArrayDynamicIndexing;
-    VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
-    VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
-    VkBool32 shaderUniformBufferArrayNonUniformIndexing;
-    VkBool32 shaderSampledImageArrayNonUniformIndexing;
-    VkBool32 shaderStorageBufferArrayNonUniformIndexing;
-    VkBool32 shaderStorageImageArrayNonUniformIndexing;
-    VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
-    VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
-    VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
-    VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
-    VkBool32 descriptorBindingSampledImageUpdateAfterBind;
-    VkBool32 descriptorBindingStorageImageUpdateAfterBind;
-    VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
-    VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
-    VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
-    VkBool32 descriptorBindingUpdateUnusedWhilePending;
-    VkBool32 descriptorBindingPartiallyBound;
-    VkBool32 descriptorBindingVariableDescriptorCount;
-    VkBool32 runtimeDescriptorArray;
-} VkPhysicalDeviceDescriptorIndexingFeatures32;
-typedef VkPhysicalDeviceDescriptorIndexingFeatures32 VkPhysicalDeviceDescriptorIndexingFeaturesEXT32;
+    VkFormatProperties formatProperties;
+} VkFormatProperties232;
+typedef VkFormatProperties232 VkFormatProperties2KHR32;

-typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures32
+typedef struct VkFormatProperties332
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 timelineSemaphore;
-} VkPhysicalDeviceTimelineSemaphoreFeatures32;
-typedef VkPhysicalDeviceTimelineSemaphoreFeatures32 VkPhysicalDeviceTimelineSemaphoreFeaturesKHR32;
+    VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingFeatures;
+    VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingFeatures;
+    VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) bufferFeatures;
+} VkFormatProperties332;
+typedef VkFormatProperties332 VkFormatProperties3KHR32;

-typedef struct VkPhysicalDevice8BitStorageFeatures32
+typedef struct VkFragmentShadingRateAttachmentInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 storageBuffer8BitAccess;
-    VkBool32 uniformAndStorageBuffer8BitAccess;
-    VkBool32 storagePushConstant8;
-} VkPhysicalDevice8BitStorageFeatures32;
-typedef VkPhysicalDevice8BitStorageFeatures32 VkPhysicalDevice8BitStorageFeaturesKHR32;
+    PTR32 pFragmentShadingRateAttachment;
+    VkExtent2D shadingRateAttachmentTexelSize;
+} VkFragmentShadingRateAttachmentInfoKHR32;

-typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT32
+typedef struct VkFrameBoundaryEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 conditionalRendering;
-    VkBool32 inheritedConditionalRendering;
-} VkPhysicalDeviceConditionalRenderingFeaturesEXT32;
+    VkFrameBoundaryFlagsEXT flags;
+    uint64_t DECLSPEC_ALIGN(8) frameID;
+    uint32_t imageCount;
+    PTR32 pImages;
+    uint32_t bufferCount;
+    PTR32 pBuffers;
+    uint64_t DECLSPEC_ALIGN(8) tagName;
+    PTR32 tagSize;
+    PTR32 pTag;
+} VkFrameBoundaryEXT32;

-typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures32
+typedef struct VkFrameBoundaryTensorsARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 vulkanMemoryModel;
-    VkBool32 vulkanMemoryModelDeviceScope;
-    VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
-} VkPhysicalDeviceVulkanMemoryModelFeatures32;
-typedef VkPhysicalDeviceVulkanMemoryModelFeatures32 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR32;
+    uint32_t tensorCount;
+    PTR32 pTensors;
+} VkFrameBoundaryTensorsARM32;

-typedef struct VkPhysicalDeviceShaderAtomicInt64Features32
+typedef struct VkFramebufferAttachmentsCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderBufferInt64Atomics;
-    VkBool32 shaderSharedInt64Atomics;
-} VkPhysicalDeviceShaderAtomicInt64Features32;
-typedef VkPhysicalDeviceShaderAtomicInt64Features32 VkPhysicalDeviceShaderAtomicInt64FeaturesKHR32;
+    uint32_t attachmentImageInfoCount;
+    PTR32 pAttachmentImageInfos;
+} VkFramebufferAttachmentsCreateInfo32;
+typedef VkFramebufferAttachmentsCreateInfo32 VkFramebufferAttachmentsCreateInfoKHR32;

-typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32
+typedef struct VkFramebufferCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderBufferFloat32Atomics;
-    VkBool32 shaderBufferFloat32AtomicAdd;
-    VkBool32 shaderBufferFloat64Atomics;
-    VkBool32 shaderBufferFloat64AtomicAdd;
-    VkBool32 shaderSharedFloat32Atomics;
-    VkBool32 shaderSharedFloat32AtomicAdd;
-    VkBool32 shaderSharedFloat64Atomics;
-    VkBool32 shaderSharedFloat64AtomicAdd;
-    VkBool32 shaderImageFloat32Atomics;
-    VkBool32 shaderImageFloat32AtomicAdd;
-    VkBool32 sparseImageFloat32Atomics;
-    VkBool32 sparseImageFloat32AtomicAdd;
-} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32;
+    VkFramebufferCreateFlags flags;
+    VkRenderPass DECLSPEC_ALIGN(8) renderPass;
+    uint32_t attachmentCount;
+    PTR32 pAttachments;
+    uint32_t width;
+    uint32_t height;
+    uint32_t layers;
+} VkFramebufferCreateInfo32;

-typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32
+typedef struct VkFramebufferMixedSamplesCombinationNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderBufferFloat16Atomics;
-    VkBool32 shaderBufferFloat16AtomicAdd;
-    VkBool32 shaderBufferFloat16AtomicMinMax;
-    VkBool32 shaderBufferFloat32AtomicMinMax;
-    VkBool32 shaderBufferFloat64AtomicMinMax;
-    VkBool32 shaderSharedFloat16Atomics;
-    VkBool32 shaderSharedFloat16AtomicAdd;
-    VkBool32 shaderSharedFloat16AtomicMinMax;
-    VkBool32 shaderSharedFloat32AtomicMinMax;
-    VkBool32 shaderSharedFloat64AtomicMinMax;
-    VkBool32 shaderImageFloat32AtomicMinMax;
-    VkBool32 sparseImageFloat32AtomicMinMax;
-} VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32;
+    VkCoverageReductionModeNV coverageReductionMode;
+    VkSampleCountFlagBits rasterizationSamples;
+    VkSampleCountFlags depthStencilSamples;
+    VkSampleCountFlags colorSamples;
+} VkFramebufferMixedSamplesCombinationNV32;

-typedef struct VkPhysicalDeviceVertexAttributeDivisorFeatures32
+typedef struct VkGeneratedCommandsInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 vertexAttributeInstanceRateDivisor;
-    VkBool32 vertexAttributeInstanceRateZeroDivisor;
-} VkPhysicalDeviceVertexAttributeDivisorFeatures32;
-typedef VkPhysicalDeviceVertexAttributeDivisorFeatures32 VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR32;
-typedef VkPhysicalDeviceVertexAttributeDivisorFeatures32 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32;
+    VkShaderStageFlags shaderStages;
+    VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet;
+    VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout;
+    VkDeviceAddress DECLSPEC_ALIGN(8) indirectAddress;
+    VkDeviceSize DECLSPEC_ALIGN(8) indirectAddressSize;
+    VkDeviceAddress DECLSPEC_ALIGN(8) preprocessAddress;
+    VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize;
+    uint32_t maxSequenceCount;
+    VkDeviceAddress DECLSPEC_ALIGN(8) sequenceCountAddress;
+    uint32_t maxDrawCount;
+} VkGeneratedCommandsInfoEXT32;

-typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT32
+typedef struct VkGeneratedCommandsInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 decodeModeSharedExponent;
-} VkPhysicalDeviceASTCDecodeFeaturesEXT32;
+    VkPipelineBindPoint pipelineBindPoint;
+    VkPipeline DECLSPEC_ALIGN(8) pipeline;
+    VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
+    uint32_t streamCount;
+    PTR32 pStreams;
+    uint32_t sequencesCount;
+    VkBuffer DECLSPEC_ALIGN(8) preprocessBuffer;
+    VkDeviceSize DECLSPEC_ALIGN(8) preprocessOffset;
+    VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize;
+    VkBuffer DECLSPEC_ALIGN(8) sequencesCountBuffer;
+    VkDeviceSize DECLSPEC_ALIGN(8) sequencesCountOffset;
+    VkBuffer DECLSPEC_ALIGN(8) sequencesIndexBuffer;
+    VkDeviceSize DECLSPEC_ALIGN(8) sequencesIndexOffset;
+} VkGeneratedCommandsInfoNV32;

-typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT32
+typedef struct VkGeneratedCommandsMemoryRequirementsInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 transformFeedback;
-    VkBool32 geometryStreams;
-} VkPhysicalDeviceTransformFeedbackFeaturesEXT32;
+    VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet;
+    VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout;
+    uint32_t maxSequenceCount;
+    uint32_t maxDrawCount;
+} VkGeneratedCommandsMemoryRequirementsInfoEXT32;

-typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32
+typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 representativeFragmentTest;
-} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32;
+    VkPipelineBindPoint pipelineBindPoint;
+    VkPipeline DECLSPEC_ALIGN(8) pipeline;
+    VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
+    uint32_t maxSequencesCount;
+} VkGeneratedCommandsMemoryRequirementsInfoNV32;

-typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV32
+typedef struct VkGeneratedCommandsPipelineInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 exclusiveScissor;
-} VkPhysicalDeviceExclusiveScissorFeaturesNV32;
+    VkPipeline DECLSPEC_ALIGN(8) pipeline;
+} VkGeneratedCommandsPipelineInfoEXT32;

-typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV32
+typedef struct VkGeneratedCommandsShaderInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 cornerSampledImage;
-} VkPhysicalDeviceCornerSampledImageFeaturesNV32;
+    uint32_t shaderCount;
+    PTR32 pShaders;
+} VkGeneratedCommandsShaderInfoEXT32;

-typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32
+typedef struct VkGetLatencyMarkerInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 computeDerivativeGroupQuads;
-    VkBool32 computeDerivativeGroupLinear;
-} VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32;
-typedef VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32;
+    uint32_t timingCount;
+    PTR32 pTimings;
+} VkGetLatencyMarkerInfoNV32;

-typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV32
+typedef struct VkGraphicsPipelineCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 imageFootprint;
-} VkPhysicalDeviceShaderImageFootprintFeaturesNV32;
+    VkPipelineCreateFlags flags;
+    uint32_t stageCount;
+    PTR32 pStages;
+    PTR32 pVertexInputState;
+    PTR32 pInputAssemblyState;
+    PTR32 pTessellationState;
+    PTR32 pViewportState;
+    PTR32 pRasterizationState;
+    PTR32 pMultisampleState;
+    PTR32 pDepthStencilState;
+    PTR32 pColorBlendState;
+    PTR32 pDynamicState;
+    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
+    VkRenderPass DECLSPEC_ALIGN(8) renderPass;
+    uint32_t subpass;
+    VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
+    int32_t basePipelineIndex;
+} VkGraphicsPipelineCreateInfo32;

-typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32
+typedef struct VkGraphicsPipelineLibraryCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 dedicatedAllocationImageAliasing;
-} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32;
+    VkGraphicsPipelineLibraryFlagsEXT flags;
+} VkGraphicsPipelineLibraryCreateInfoEXT32;

-typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32
+typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 indirectCopy;
-} VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32;
+    uint32_t groupCount;
+    PTR32 pGroups;
+    uint32_t pipelineCount;
+    PTR32 pPipelines;
+} VkGraphicsPipelineShaderGroupsCreateInfoNV32;

-typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV32
+typedef struct VkHdrMetadataEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 memoryDecompression;
-} VkPhysicalDeviceMemoryDecompressionFeaturesNV32;
+    VkXYColorEXT displayPrimaryRed;
+    VkXYColorEXT displayPrimaryGreen;
+    VkXYColorEXT displayPrimaryBlue;
+    VkXYColorEXT whitePoint;
+    float maxLuminance;
+    float minLuminance;
+    float maxContentLightLevel;
+    float maxFrameAverageLightLevel;
+} VkHdrMetadataEXT32;

-typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV32
+typedef struct VkHdrVividDynamicMetadataHUAWEI32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shadingRateImage;
-    VkBool32 shadingRateCoarseSampleOrder;
-} VkPhysicalDeviceShadingRateImageFeaturesNV32;
+    PTR32 dynamicMetadataSize;
+    PTR32 pDynamicMetadata;
+} VkHdrVividDynamicMetadataHUAWEI32;

-typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32
+typedef struct VkHostImageCopyDevicePerformanceQuery32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 invocationMask;
-} VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32;
+    VkBool32 optimalDeviceAccess;
+    VkBool32 identicalMemoryLayout;
+} VkHostImageCopyDevicePerformanceQuery32;
+typedef VkHostImageCopyDevicePerformanceQuery32 VkHostImageCopyDevicePerformanceQueryEXT32;

-typedef struct VkPhysicalDeviceMeshShaderFeaturesNV32
+typedef struct VkHostImageLayoutTransitionInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 taskShader;
-    VkBool32 meshShader;
-} VkPhysicalDeviceMeshShaderFeaturesNV32;
+    VkImage DECLSPEC_ALIGN(8) image;
+    VkImageLayout oldLayout;
+    VkImageLayout newLayout;
+    VkImageSubresourceRange subresourceRange;
+} VkHostImageLayoutTransitionInfo32;
+typedef VkHostImageLayoutTransitionInfo32 VkHostImageLayoutTransitionInfoEXT32;

-typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT32
+typedef struct VkImageAlignmentControlCreateInfoMESA32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 taskShader;
-    VkBool32 meshShader;
-    VkBool32 multiviewMeshShader;
-    VkBool32 primitiveFragmentShadingRateMeshShader;
-    VkBool32 meshShaderQueries;
-} VkPhysicalDeviceMeshShaderFeaturesEXT32;
+    uint32_t maximumRequestedAlignment;
+} VkImageAlignmentControlCreateInfoMESA32;

-typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR32
+typedef struct VkImageCaptureDescriptorDataInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 accelerationStructure;
-    VkBool32 accelerationStructureCaptureReplay;
-    VkBool32 accelerationStructureIndirectBuild;
-    VkBool32 accelerationStructureHostCommands;
-    VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind;
-} VkPhysicalDeviceAccelerationStructureFeaturesKHR32;
+    VkImage DECLSPEC_ALIGN(8) image;
+} VkImageCaptureDescriptorDataInfoEXT32;

-typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR32
+typedef struct VkImageCompressionControlEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 rayTracingPipeline;
-    VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay;
-    VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
-    VkBool32 rayTracingPipelineTraceRaysIndirect;
-    VkBool32 rayTraversalPrimitiveCulling;
-} VkPhysicalDeviceRayTracingPipelineFeaturesKHR32;
+    VkImageCompressionFlagsEXT flags;
+    uint32_t compressionControlPlaneCount;
+    PTR32 pFixedRateFlags;
+} VkImageCompressionControlEXT32;

-typedef struct VkPhysicalDeviceRayQueryFeaturesKHR32
+typedef struct VkImageCompressionPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 rayQuery;
-} VkPhysicalDeviceRayQueryFeaturesKHR32;
+    VkImageCompressionFlagsEXT imageCompressionFlags;
+    VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags;
+} VkImageCompressionPropertiesEXT32;

-typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32
+typedef struct VkImageFormatListCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 rayTracingMaintenance1;
-    VkBool32 rayTracingPipelineTraceRaysIndirect2;
-} VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32;
+    uint32_t viewFormatCount;
+    PTR32 pViewFormats;
+} VkImageFormatListCreateInfo32;
+typedef VkImageFormatListCreateInfo32 VkImageFormatListCreateInfoKHR32;

-typedef struct VkDeviceMemoryOverallocationCreateInfoAMD32
+typedef struct VkImageFormatProperties232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkMemoryOverallocationBehaviorAMD overallocationBehavior;
-} VkDeviceMemoryOverallocationCreateInfoAMD32;
+    VkImageFormatProperties32 DECLSPEC_ALIGN(8) imageFormatProperties;
+} VkImageFormatProperties232;
+typedef VkImageFormatProperties232 VkImageFormatProperties2KHR32;

-typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT32
+typedef struct VkImageMemoryBarrier32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 fragmentDensityMap;
-    VkBool32 fragmentDensityMapDynamic;
-    VkBool32 fragmentDensityMapNonSubsampledImages;
-} VkPhysicalDeviceFragmentDensityMapFeaturesEXT32;
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+    VkImageLayout oldLayout;
+    VkImageLayout newLayout;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    VkImage DECLSPEC_ALIGN(8) image;
+    VkImageSubresourceRange subresourceRange;
+} VkImageMemoryBarrier32;

-typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32
+typedef struct VkImageMemoryRequirementsInfo232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 fragmentDensityMapDeferred;
-} VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32;
+    VkImage DECLSPEC_ALIGN(8) image;
+} VkImageMemoryRequirementsInfo232;
+typedef VkImageMemoryRequirementsInfo232 VkImageMemoryRequirementsInfo2KHR32;

-typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32
+typedef struct VkImagePlaneMemoryRequirementsInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 fragmentDensityMapOffset;
-} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32;
-typedef VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32;
+    VkImageAspectFlagBits planeAspect;
+} VkImagePlaneMemoryRequirementsInfo32;
+typedef VkImagePlaneMemoryRequirementsInfo32 VkImagePlaneMemoryRequirementsInfoKHR32;

-typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures32
+typedef struct VkImageSparseMemoryRequirementsInfo232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 scalarBlockLayout;
-} VkPhysicalDeviceScalarBlockLayoutFeatures32;
-typedef VkPhysicalDeviceScalarBlockLayoutFeatures32 VkPhysicalDeviceScalarBlockLayoutFeaturesEXT32;
+    VkImage DECLSPEC_ALIGN(8) image;
+} VkImageSparseMemoryRequirementsInfo232;
+typedef VkImageSparseMemoryRequirementsInfo232 VkImageSparseMemoryRequirementsInfo2KHR32;

-typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures32
+typedef struct VkImageStencilUsageCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 uniformBufferStandardLayout;
-} VkPhysicalDeviceUniformBufferStandardLayoutFeatures32;
-typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR32;
+    VkImageUsageFlags stencilUsage;
+} VkImageStencilUsageCreateInfo32;
+typedef VkImageStencilUsageCreateInfo32 VkImageStencilUsageCreateInfoEXT32;

-typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT32
+typedef struct VkImageSwapchainCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 depthClipEnable;
-} VkPhysicalDeviceDepthClipEnableFeaturesEXT32;
+    VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
+} VkImageSwapchainCreateInfoKHR32;

-typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT32
+typedef struct VkImageViewASTCDecodeModeEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 memoryPriority;
-} VkPhysicalDeviceMemoryPriorityFeaturesEXT32;
+    VkFormat decodeMode;
+} VkImageViewASTCDecodeModeEXT32;

-typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32
+typedef struct VkImageViewAddressPropertiesNVX32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 pageableDeviceLocalMemory;
-} VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32;
+    VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+} VkImageViewAddressPropertiesNVX32;

-typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures32
+typedef struct VkImageViewCaptureDescriptorDataInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 bufferDeviceAddress;
-    VkBool32 bufferDeviceAddressCaptureReplay;
-    VkBool32 bufferDeviceAddressMultiDevice;
-} VkPhysicalDeviceBufferDeviceAddressFeatures32;
-typedef VkPhysicalDeviceBufferDeviceAddressFeatures32 VkPhysicalDeviceBufferDeviceAddressFeaturesKHR32;
+    VkImageView DECLSPEC_ALIGN(8) imageView;
+} VkImageViewCaptureDescriptorDataInfoEXT32;

-typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32
+typedef struct VkImageViewCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 bufferDeviceAddress;
-    VkBool32 bufferDeviceAddressCaptureReplay;
-    VkBool32 bufferDeviceAddressMultiDevice;
-} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32;
-typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 VkPhysicalDeviceBufferAddressFeaturesEXT32;
+    VkImageViewCreateFlags flags;
+    VkImage DECLSPEC_ALIGN(8) image;
+    VkImageViewType viewType;
+    VkFormat format;
+    VkComponentMapping components;
+    VkImageSubresourceRange subresourceRange;
+} VkImageViewCreateInfo32;

-typedef struct VkPhysicalDeviceImagelessFramebufferFeatures32
+typedef struct VkImageViewHandleInfoNVX32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 imagelessFramebuffer;
-} VkPhysicalDeviceImagelessFramebufferFeatures32;
-typedef VkPhysicalDeviceImagelessFramebufferFeatures32 VkPhysicalDeviceImagelessFramebufferFeaturesKHR32;
+    VkImageView DECLSPEC_ALIGN(8) imageView;
+    VkDescriptorType descriptorType;
+    VkSampler DECLSPEC_ALIGN(8) sampler;
+} VkImageViewHandleInfoNVX32;

-typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures32
+typedef struct VkImageViewMinLodCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 textureCompressionASTC_HDR;
-} VkPhysicalDeviceTextureCompressionASTCHDRFeatures32;
-typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT32;
+    float minLod;
+} VkImageViewMinLodCreateInfoEXT32;

-typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV32
+typedef struct VkImageViewSampleWeightCreateInfoQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 cooperativeMatrix;
-    VkBool32 cooperativeMatrixRobustBufferAccess;
-} VkPhysicalDeviceCooperativeMatrixFeaturesNV32;
+    VkOffset2D filterCenter;
+    VkExtent2D filterSize;
+    uint32_t numPhases;
+} VkImageViewSampleWeightCreateInfoQCOM32;

-typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32
+typedef struct VkImageViewSlicedCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 ycbcrImageArrays;
-} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32;
+    uint32_t sliceOffset;
+    uint32_t sliceCount;
+} VkImageViewSlicedCreateInfoEXT32;

-typedef struct VkPhysicalDevicePresentBarrierFeaturesNV32
+typedef struct VkImageViewUsageCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 presentBarrier;
-} VkPhysicalDevicePresentBarrierFeaturesNV32;
+    VkImageUsageFlags usage;
+} VkImageViewUsageCreateInfo32;
+typedef VkImageViewUsageCreateInfo32 VkImageViewUsageCreateInfoKHR32;

-typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR32
+typedef struct VkImportMemoryHostPointerInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 performanceCounterQueryPools;
-    VkBool32 performanceCounterMultipleQueryPools;
-} VkPhysicalDevicePerformanceQueryFeaturesKHR32;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+    PTR32 pHostPointer;
+} VkImportMemoryHostPointerInfoEXT32;

-typedef struct VkPerformanceQueryReservationInfoKHR32
+typedef struct VkImportMemoryWin32HandleInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxPerformanceQueriesPerPool;
-} VkPerformanceQueryReservationInfoKHR32;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+    HANDLE handle;
+    LPCWSTR name;
+} VkImportMemoryWin32HandleInfoKHR32;

-typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV32
+typedef struct VkIndirectCommandsLayoutCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 coverageReductionMode;
-} VkPhysicalDeviceCoverageReductionModeFeaturesNV32;
+    VkIndirectCommandsLayoutUsageFlagsEXT flags;
+    VkShaderStageFlags shaderStages;
+    uint32_t indirectStride;
+    VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
+    uint32_t tokenCount;
+    PTR32 pTokens;
+} VkIndirectCommandsLayoutCreateInfoEXT32;

-typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32
+typedef struct VkIndirectCommandsLayoutCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderIntegerFunctions2;
-} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32;
+    VkIndirectCommandsLayoutUsageFlagsNV flags;
+    VkPipelineBindPoint pipelineBindPoint;
+    uint32_t tokenCount;
+    PTR32 pTokens;
+    uint32_t streamCount;
+    PTR32 pStreamStrides;
+} VkIndirectCommandsLayoutCreateInfoNV32;

-typedef struct VkPhysicalDeviceShaderClockFeaturesKHR32
+typedef struct VkIndirectExecutionSetCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderSubgroupClock;
-    VkBool32 shaderDeviceClock;
-} VkPhysicalDeviceShaderClockFeaturesKHR32;
+    VkIndirectExecutionSetInfoTypeEXT type;
+    VkIndirectExecutionSetInfoEXT32 info;
+} VkIndirectExecutionSetCreateInfoEXT32;
+
+typedef struct VkInitializePerformanceApiInfoINTEL32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    PTR32 pUserData;
+} VkInitializePerformanceApiInfoINTEL32;

-typedef struct VkPhysicalDeviceIndexTypeUint8Features32
+typedef struct VkInstanceCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 indexTypeUint8;
-} VkPhysicalDeviceIndexTypeUint8Features32;
-typedef VkPhysicalDeviceIndexTypeUint8Features32 VkPhysicalDeviceIndexTypeUint8FeaturesKHR32;
-typedef VkPhysicalDeviceIndexTypeUint8Features32 VkPhysicalDeviceIndexTypeUint8FeaturesEXT32;
+    VkInstanceCreateFlags flags;
+    PTR32 pApplicationInfo;
+    uint32_t enabledLayerCount;
+    PTR32 ppEnabledLayerNames;
+    uint32_t enabledExtensionCount;
+    PTR32 ppEnabledExtensionNames;
+} VkInstanceCreateInfo32;

-typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32
+typedef struct VkLatencySleepInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderSMBuiltins;
-} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32;
+    VkSemaphore DECLSPEC_ALIGN(8) signalSemaphore;
+    uint64_t DECLSPEC_ALIGN(8) value;
+} VkLatencySleepInfoNV32;

-typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32
+typedef struct VkLatencySleepModeInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 fragmentShaderSampleInterlock;
-    VkBool32 fragmentShaderPixelInterlock;
-    VkBool32 fragmentShaderShadingRateInterlock;
-} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32;
+    VkBool32 lowLatencyMode;
+    VkBool32 lowLatencyBoost;
+    uint32_t minimumIntervalUs;
+} VkLatencySleepModeInfoNV32;

-typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32
+typedef struct VkLatencySubmissionPresentIdNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 separateDepthStencilLayouts;
-} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32;
-typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR32;
+    uint64_t DECLSPEC_ALIGN(8) presentID;
+} VkLatencySubmissionPresentIdNV32;

-typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32
+typedef struct VkLatencySurfaceCapabilitiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 primitiveTopologyListRestart;
-    VkBool32 primitiveTopologyPatchListRestart;
-} VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32;
+    uint32_t presentModeCount;
+    PTR32 pPresentModes;
+} VkLatencySurfaceCapabilitiesNV32;

-typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32
+typedef struct VkLayerSettingsCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 pipelineExecutableInfo;
-} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32;
+    uint32_t settingCount;
+    PTR32 pSettings;
+} VkLayerSettingsCreateInfoEXT32;

-typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32
+typedef struct VkMappedMemoryRange32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderDemoteToHelperInvocation;
-} VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32;
-typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT32;
+    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
+    VkDeviceSize DECLSPEC_ALIGN(8) offset;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+} VkMappedMemoryRange32;

-typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32
+typedef struct VkMemoryAllocateFlagsInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 texelBufferAlignment;
-} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32;
+    VkMemoryAllocateFlags flags;
+    uint32_t deviceMask;
+} VkMemoryAllocateFlagsInfo32;
+typedef VkMemoryAllocateFlagsInfo32 VkMemoryAllocateFlagsInfoKHR32;

-typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures32
+typedef struct VkMemoryAllocateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 subgroupSizeControl;
-    VkBool32 computeFullSubgroups;
-} VkPhysicalDeviceSubgroupSizeControlFeatures32;
-typedef VkPhysicalDeviceSubgroupSizeControlFeatures32 VkPhysicalDeviceSubgroupSizeControlFeaturesEXT32;
+    VkDeviceSize DECLSPEC_ALIGN(8) allocationSize;
+    uint32_t memoryTypeIndex;
+} VkMemoryAllocateInfo32;

-typedef struct VkPhysicalDeviceLineRasterizationFeatures32
+typedef struct VkMemoryBarrier32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 rectangularLines;
-    VkBool32 bresenhamLines;
-    VkBool32 smoothLines;
-    VkBool32 stippledRectangularLines;
-    VkBool32 stippledBresenhamLines;
-    VkBool32 stippledSmoothLines;
-} VkPhysicalDeviceLineRasterizationFeatures32;
-typedef VkPhysicalDeviceLineRasterizationFeatures32 VkPhysicalDeviceLineRasterizationFeaturesKHR32;
-typedef VkPhysicalDeviceLineRasterizationFeatures32 VkPhysicalDeviceLineRasterizationFeaturesEXT32;
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+} VkMemoryBarrier32;

-typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures32
+typedef struct VkMemoryBarrierAccessFlags3KHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 pipelineCreationCacheControl;
-} VkPhysicalDevicePipelineCreationCacheControlFeatures32;
-typedef VkPhysicalDevicePipelineCreationCacheControlFeatures32 VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT32;
+    VkAccessFlags3KHR DECLSPEC_ALIGN(8) srcAccessMask3;
+    VkAccessFlags3KHR DECLSPEC_ALIGN(8) dstAccessMask3;
+} VkMemoryBarrierAccessFlags3KHR32;

-typedef struct VkPhysicalDeviceVulkan11Features32
+typedef struct VkMemoryDedicatedAllocateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 storageBuffer16BitAccess;
-    VkBool32 uniformAndStorageBuffer16BitAccess;
-    VkBool32 storagePushConstant16;
-    VkBool32 storageInputOutput16;
-    VkBool32 multiview;
-    VkBool32 multiviewGeometryShader;
-    VkBool32 multiviewTessellationShader;
-    VkBool32 variablePointersStorageBuffer;
-    VkBool32 variablePointers;
-    VkBool32 protectedMemory;
-    VkBool32 samplerYcbcrConversion;
-    VkBool32 shaderDrawParameters;
-} VkPhysicalDeviceVulkan11Features32;
+    VkImage DECLSPEC_ALIGN(8) image;
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+} VkMemoryDedicatedAllocateInfo32;
+typedef VkMemoryDedicatedAllocateInfo32 VkMemoryDedicatedAllocateInfoKHR32;

-typedef struct VkPhysicalDeviceVulkan12Features32
+typedef struct VkMemoryDedicatedAllocateInfoTensorARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 samplerMirrorClampToEdge;
-    VkBool32 drawIndirectCount;
-    VkBool32 storageBuffer8BitAccess;
-    VkBool32 uniformAndStorageBuffer8BitAccess;
-    VkBool32 storagePushConstant8;
-    VkBool32 shaderBufferInt64Atomics;
-    VkBool32 shaderSharedInt64Atomics;
-    VkBool32 shaderFloat16;
-    VkBool32 shaderInt8;
-    VkBool32 descriptorIndexing;
-    VkBool32 shaderInputAttachmentArrayDynamicIndexing;
-    VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
-    VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
-    VkBool32 shaderUniformBufferArrayNonUniformIndexing;
-    VkBool32 shaderSampledImageArrayNonUniformIndexing;
-    VkBool32 shaderStorageBufferArrayNonUniformIndexing;
-    VkBool32 shaderStorageImageArrayNonUniformIndexing;
-    VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
-    VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
-    VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
-    VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
-    VkBool32 descriptorBindingSampledImageUpdateAfterBind;
-    VkBool32 descriptorBindingStorageImageUpdateAfterBind;
-    VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
-    VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
-    VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
-    VkBool32 descriptorBindingUpdateUnusedWhilePending;
-    VkBool32 descriptorBindingPartiallyBound;
-    VkBool32 descriptorBindingVariableDescriptorCount;
-    VkBool32 runtimeDescriptorArray;
-    VkBool32 samplerFilterMinmax;
-    VkBool32 scalarBlockLayout;
-    VkBool32 imagelessFramebuffer;
-    VkBool32 uniformBufferStandardLayout;
-    VkBool32 shaderSubgroupExtendedTypes;
-    VkBool32 separateDepthStencilLayouts;
-    VkBool32 hostQueryReset;
-    VkBool32 timelineSemaphore;
-    VkBool32 bufferDeviceAddress;
-    VkBool32 bufferDeviceAddressCaptureReplay;
-    VkBool32 bufferDeviceAddressMultiDevice;
-    VkBool32 vulkanMemoryModel;
-    VkBool32 vulkanMemoryModelDeviceScope;
-    VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
-    VkBool32 shaderOutputViewportIndex;
-    VkBool32 shaderOutputLayer;
-    VkBool32 subgroupBroadcastDynamicId;
-} VkPhysicalDeviceVulkan12Features32;
+    VkTensorARM DECLSPEC_ALIGN(8) tensor;
+} VkMemoryDedicatedAllocateInfoTensorARM32;

-typedef struct VkPhysicalDeviceVulkan13Features32
+typedef struct VkMemoryDedicatedRequirements32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 robustImageAccess;
-    VkBool32 inlineUniformBlock;
-    VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
-    VkBool32 pipelineCreationCacheControl;
-    VkBool32 privateData;
-    VkBool32 shaderDemoteToHelperInvocation;
-    VkBool32 shaderTerminateInvocation;
-    VkBool32 subgroupSizeControl;
-    VkBool32 computeFullSubgroups;
-    VkBool32 synchronization2;
-    VkBool32 textureCompressionASTC_HDR;
-    VkBool32 shaderZeroInitializeWorkgroupMemory;
-    VkBool32 dynamicRendering;
-    VkBool32 shaderIntegerDotProduct;
-    VkBool32 maintenance4;
-} VkPhysicalDeviceVulkan13Features32;
+    VkBool32 prefersDedicatedAllocation;
+    VkBool32 requiresDedicatedAllocation;
+} VkMemoryDedicatedRequirements32;
+typedef VkMemoryDedicatedRequirements32 VkMemoryDedicatedRequirementsKHR32;

-typedef struct VkPhysicalDeviceVulkan14Features32
+typedef struct VkMemoryHostPointerPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 globalPriorityQuery;
-    VkBool32 shaderSubgroupRotate;
-    VkBool32 shaderSubgroupRotateClustered;
-    VkBool32 shaderFloatControls2;
-    VkBool32 shaderExpectAssume;
-    VkBool32 rectangularLines;
-    VkBool32 bresenhamLines;
-    VkBool32 smoothLines;
-    VkBool32 stippledRectangularLines;
-    VkBool32 stippledBresenhamLines;
-    VkBool32 stippledSmoothLines;
-    VkBool32 vertexAttributeInstanceRateDivisor;
-    VkBool32 vertexAttributeInstanceRateZeroDivisor;
-    VkBool32 indexTypeUint8;
-    VkBool32 dynamicRenderingLocalRead;
-    VkBool32 maintenance5;
-    VkBool32 maintenance6;
-    VkBool32 pipelineProtectedAccess;
-    VkBool32 pipelineRobustness;
-    VkBool32 hostImageCopy;
-    VkBool32 pushDescriptor;
-} VkPhysicalDeviceVulkan14Features32;
+    uint32_t memoryTypeBits;
+} VkMemoryHostPointerPropertiesEXT32;

-typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD32
+typedef struct VkMemoryMapInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 deviceCoherentMemory;
-} VkPhysicalDeviceCoherentMemoryFeaturesAMD32;
+    VkMemoryMapFlags flags;
+    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
+    VkDeviceSize DECLSPEC_ALIGN(8) offset;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+} VkMemoryMapInfo32;
+typedef VkMemoryMapInfo32 VkMemoryMapInfoKHR32;

-typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT32
+typedef struct VkMemoryMapPlacedInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 customBorderColors;
-    VkBool32 customBorderColorWithoutFormat;
-} VkPhysicalDeviceCustomBorderColorFeaturesEXT32;
+    PTR32 pPlacedAddress;
+} VkMemoryMapPlacedInfoEXT32;

-typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32
+typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 borderColorSwizzle;
-    VkBool32 borderColorSwizzleFromImage;
-} VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32;
+    uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
+} VkMemoryOpaqueCaptureAddressAllocateInfo32;
+typedef VkMemoryOpaqueCaptureAddressAllocateInfo32 VkMemoryOpaqueCaptureAddressAllocateInfoKHR32;

-typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32
+typedef struct VkMemoryPriorityAllocateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 extendedDynamicState;
-} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32;
+    float priority;
+} VkMemoryPriorityAllocateInfoEXT32;

-typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32
+typedef struct VkMemoryRequirements232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 extendedDynamicState2;
-    VkBool32 extendedDynamicState2LogicOp;
-    VkBool32 extendedDynamicState2PatchControlPoints;
-} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32;
+    VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
+} VkMemoryRequirements232;
+typedef VkMemoryRequirements232 VkMemoryRequirements2KHR32;

-typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32
+
+typedef struct VkMemoryUnmapInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 extendedDynamicState3TessellationDomainOrigin;
-    VkBool32 extendedDynamicState3DepthClampEnable;
-    VkBool32 extendedDynamicState3PolygonMode;
-    VkBool32 extendedDynamicState3RasterizationSamples;
-    VkBool32 extendedDynamicState3SampleMask;
-    VkBool32 extendedDynamicState3AlphaToCoverageEnable;
-    VkBool32 extendedDynamicState3AlphaToOneEnable;
-    VkBool32 extendedDynamicState3LogicOpEnable;
-    VkBool32 extendedDynamicState3ColorBlendEnable;
-    VkBool32 extendedDynamicState3ColorBlendEquation;
-    VkBool32 extendedDynamicState3ColorWriteMask;
-    VkBool32 extendedDynamicState3RasterizationStream;
-    VkBool32 extendedDynamicState3ConservativeRasterizationMode;
-    VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize;
-    VkBool32 extendedDynamicState3DepthClipEnable;
-    VkBool32 extendedDynamicState3SampleLocationsEnable;
-    VkBool32 extendedDynamicState3ColorBlendAdvanced;
-    VkBool32 extendedDynamicState3ProvokingVertexMode;
-    VkBool32 extendedDynamicState3LineRasterizationMode;
-    VkBool32 extendedDynamicState3LineStippleEnable;
-    VkBool32 extendedDynamicState3DepthClipNegativeOneToOne;
-    VkBool32 extendedDynamicState3ViewportWScalingEnable;
-    VkBool32 extendedDynamicState3ViewportSwizzle;
-    VkBool32 extendedDynamicState3CoverageToColorEnable;
-    VkBool32 extendedDynamicState3CoverageToColorLocation;
-    VkBool32 extendedDynamicState3CoverageModulationMode;
-    VkBool32 extendedDynamicState3CoverageModulationTableEnable;
-    VkBool32 extendedDynamicState3CoverageModulationTable;
-    VkBool32 extendedDynamicState3CoverageReductionMode;
-    VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable;
-    VkBool32 extendedDynamicState3ShadingRateImageEnable;
-} VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32;
+    VkMemoryUnmapFlags flags;
+    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
+} VkMemoryUnmapInfo32;
+typedef VkMemoryUnmapInfo32 VkMemoryUnmapInfoKHR32;

-typedef struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32
+typedef struct VkMicromapBuildInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 partitionedAccelerationStructure;
-} VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32;
+    VkMicromapTypeEXT type;
+    VkBuildMicromapFlagsEXT flags;
+    VkBuildMicromapModeEXT mode;
+    VkMicromapEXT DECLSPEC_ALIGN(8) dstMicromap;
+    uint32_t usageCountsCount;
+    PTR32 pUsageCounts;
+    PTR32 ppUsageCounts;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
+    VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
+    VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) triangleArray;
+    VkDeviceSize DECLSPEC_ALIGN(8) triangleArrayStride;
+} VkMicromapBuildInfoEXT32;

-typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV32
+typedef struct VkMicromapBuildSizesInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 diagnosticsConfig;
-} VkPhysicalDeviceDiagnosticsConfigFeaturesNV32;
+    VkDeviceSize DECLSPEC_ALIGN(8) micromapSize;
+    VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
+    VkBool32 discardable;
+} VkMicromapBuildSizesInfoEXT32;

-typedef struct VkDeviceDiagnosticsConfigCreateInfoNV32
+typedef struct VkMicromapCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceDiagnosticsConfigFlagsNV flags;
-} VkDeviceDiagnosticsConfigCreateInfoNV32;
+    VkMicromapCreateFlagsEXT createFlags;
+    VkBuffer DECLSPEC_ALIGN(8) buffer;
+    VkDeviceSize DECLSPEC_ALIGN(8) offset;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+    VkMicromapTypeEXT type;
+    VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
+} VkMicromapCreateInfoEXT32;

-typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32
+typedef struct VkMicromapVersionInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderZeroInitializeWorkgroupMemory;
-} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32;
-typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR32;
+    PTR32 pVersionData;
+} VkMicromapVersionInfoEXT32;

-typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32
+typedef struct VkMultisamplePropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderSubgroupUniformControlFlow;
-} VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32;
+    VkExtent2D maxSampleLocationGridSize;
+} VkMultisamplePropertiesEXT32;

-typedef struct VkPhysicalDeviceRobustness2FeaturesKHR32
+typedef struct VkMultisampledRenderToSingleSampledInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 robustBufferAccess2;
-    VkBool32 robustImageAccess2;
-    VkBool32 nullDescriptor;
-} VkPhysicalDeviceRobustness2FeaturesKHR32;
-typedef VkPhysicalDeviceRobustness2FeaturesKHR32 VkPhysicalDeviceRobustness2FeaturesEXT32;
+    VkBool32 multisampledRenderToSingleSampledEnable;
+    VkSampleCountFlagBits rasterizationSamples;
+} VkMultisampledRenderToSingleSampledInfoEXT32;

-typedef struct VkPhysicalDeviceImageRobustnessFeatures32
+typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 robustImageAccess;
-} VkPhysicalDeviceImageRobustnessFeatures32;
-typedef VkPhysicalDeviceImageRobustnessFeatures32 VkPhysicalDeviceImageRobustnessFeaturesEXT32;
+    uint32_t perViewRenderAreaCount;
+    PTR32 pPerViewRenderAreas;
+} VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32;

-typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32
+typedef struct VkMutableDescriptorTypeCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 workgroupMemoryExplicitLayout;
-    VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout;
-    VkBool32 workgroupMemoryExplicitLayout8BitAccess;
-    VkBool32 workgroupMemoryExplicitLayout16BitAccess;
-} VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32;
+    uint32_t mutableDescriptorTypeListCount;
+    PTR32 pMutableDescriptorTypeLists;
+} VkMutableDescriptorTypeCreateInfoEXT32;
+typedef VkMutableDescriptorTypeCreateInfoEXT32 VkMutableDescriptorTypeCreateInfoVALVE32;

-typedef struct VkPhysicalDevice4444FormatsFeaturesEXT32
+typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 formatA4R4G4B4;
-    VkBool32 formatA4B4G4R4;
-} VkPhysicalDevice4444FormatsFeaturesEXT32;
+    PTR32 opaqueCaptureDescriptorData;
+} VkOpaqueCaptureDescriptorDataCreateInfoEXT32;

-typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32
+typedef struct VkOpticalFlowExecuteInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 subpassShading;
-} VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32;
+    VkOpticalFlowExecuteFlagsNV flags;
+    uint32_t regionCount;
+    PTR32 pRegions;
+} VkOpticalFlowExecuteInfoNV32;

-typedef struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32
+typedef struct VkOpticalFlowImageFormatInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 clustercullingShader;
-    VkBool32 multiviewClusterCullingShader;
-} VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32;
+    VkOpticalFlowUsageFlagsNV usage;
+} VkOpticalFlowImageFormatInfoNV32;

-typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32
+typedef struct VkOpticalFlowImageFormatPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderImageInt64Atomics;
-    VkBool32 sparseImageInt64Atomics;
-} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32;
+    VkFormat format;
+} VkOpticalFlowImageFormatPropertiesNV32;

-typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR32
+typedef struct VkOpticalFlowSessionCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 pipelineFragmentShadingRate;
-    VkBool32 primitiveFragmentShadingRate;
-    VkBool32 attachmentFragmentShadingRate;
-} VkPhysicalDeviceFragmentShadingRateFeaturesKHR32;
+    uint32_t width;
+    uint32_t height;
+    VkFormat imageFormat;
+    VkFormat flowVectorFormat;
+    VkFormat costFormat;
+    VkOpticalFlowGridSizeFlagsNV outputGridSize;
+    VkOpticalFlowGridSizeFlagsNV hintGridSize;
+    VkOpticalFlowPerformanceLevelNV performanceLevel;
+    VkOpticalFlowSessionCreateFlagsNV flags;
+} VkOpticalFlowSessionCreateInfoNV32;

-typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures32
+typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderTerminateInvocation;
-} VkPhysicalDeviceShaderTerminateInvocationFeatures32;
-typedef VkPhysicalDeviceShaderTerminateInvocationFeatures32 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR32;
+    uint32_t id;
+    uint32_t size;
+    PTR32 pPrivateData;
+} VkOpticalFlowSessionCreatePrivateDataInfoNV32;

-typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32
+typedef struct VkOutOfBandQueueTypeInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 fragmentShadingRateEnums;
-    VkBool32 supersampleFragmentShadingRates;
-    VkBool32 noInvocationFragmentShadingRates;
-} VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32;
+    VkOutOfBandQueueTypeNV queueType;
+} VkOutOfBandQueueTypeInfoNV32;

-typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32
+typedef struct VkPartitionedAccelerationStructureFlagsNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 image2DViewOf3D;
-    VkBool32 sampler2DViewOf3D;
-} VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32;
+    VkBool32 enablePartitionTranslation;
+} VkPartitionedAccelerationStructureFlagsNV32;

-typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32
+typedef struct VkPerTileBeginInfoQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 imageSlicedViewOf3D;
-} VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32;
+} VkPerTileBeginInfoQCOM32;

-typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32
+typedef struct VkPerTileEndInfoQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 attachmentFeedbackLoopDynamicState;
-} VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32;
+} VkPerTileEndInfoQCOM32;

-typedef struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32
+typedef struct VkPerformanceConfigurationAcquireInfoINTEL32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 legacyVertexAttributes;
-} VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32;
+    VkPerformanceConfigurationTypeINTEL type;
+} VkPerformanceConfigurationAcquireInfoINTEL32;

-typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32
+typedef struct VkPerformanceCounterDescriptionKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 mutableDescriptorType;
-} VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32;
-typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE32;
+    VkPerformanceCounterDescriptionFlagsKHR flags;
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char category[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+} VkPerformanceCounterDescriptionKHR32;

-typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT32
+typedef struct VkPerformanceCounterKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 depthClipControl;
-} VkPhysicalDeviceDepthClipControlFeaturesEXT32;
+    VkPerformanceCounterUnitKHR unit;
+    VkPerformanceCounterScopeKHR scope;
+    VkPerformanceCounterStorageKHR storage;
+    uint8_t uuid[VK_UUID_SIZE];
+} VkPerformanceCounterKHR32;

-typedef struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32
+typedef struct VkPerformanceMarkerInfoINTEL32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 zeroInitializeDeviceMemory;
-} VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32;
+    uint64_t DECLSPEC_ALIGN(8) marker;
+} VkPerformanceMarkerInfoINTEL32;

-typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32
+typedef struct VkPerformanceOverrideInfoINTEL32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 deviceGeneratedCommands;
-    VkBool32 dynamicGeneratedPipelineLayout;
-} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32;
+    VkPerformanceOverrideTypeINTEL type;
+    VkBool32 enable;
+    uint64_t DECLSPEC_ALIGN(8) parameter;
+} VkPerformanceOverrideInfoINTEL32;

-typedef struct VkPhysicalDeviceDepthClampControlFeaturesEXT32
+typedef struct VkPerformanceQueryReservationInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 depthClampControl;
-} VkPhysicalDeviceDepthClampControlFeaturesEXT32;
+    uint32_t maxPerformanceQueriesPerPool;
+} VkPerformanceQueryReservationInfoKHR32;

-typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32
+typedef struct VkPerformanceQuerySubmitInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 vertexInputDynamicState;
-} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32;
+    uint32_t counterPassIndex;
+} VkPerformanceQuerySubmitInfoKHR32;

-typedef struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32
+typedef struct VkPerformanceStreamMarkerInfoINTEL32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderRelaxedExtendedInstruction;
-} VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32;
+    uint32_t marker;
+} VkPerformanceStreamMarkerInfoINTEL32;

-typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT32
+typedef struct VkPerformanceValueINTEL32
 {
-    VkStructureType sType;
-    PTR32 pNext;
-    VkBool32 colorWriteEnable;
-} VkPhysicalDeviceColorWriteEnableFeaturesEXT32;
+    VkPerformanceValueTypeINTEL type;
+    VkPerformanceValueDataINTEL32 DECLSPEC_ALIGN(8) data;
+} VkPerformanceValueINTEL32;

-typedef struct VkPhysicalDeviceSynchronization2Features32
+typedef struct VkPhysicalDevice16BitStorageFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 synchronization2;
-} VkPhysicalDeviceSynchronization2Features32;
-typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronization2FeaturesKHR32;
+    VkBool32 storageBuffer16BitAccess;
+    VkBool32 uniformAndStorageBuffer16BitAccess;
+    VkBool32 storagePushConstant16;
+    VkBool32 storageInputOutput16;
+} VkPhysicalDevice16BitStorageFeatures32;
+typedef VkPhysicalDevice16BitStorageFeatures32 VkPhysicalDevice16BitStorageFeaturesKHR32;

-typedef struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32
+typedef struct VkPhysicalDevice4444FormatsFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 unifiedImageLayouts;
-    VkBool32 unifiedImageLayoutsVideo;
-} VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32;
+    VkBool32 formatA4R4G4B4;
+    VkBool32 formatA4B4G4R4;
+} VkPhysicalDevice4444FormatsFeaturesEXT32;

-typedef struct VkPhysicalDeviceHostImageCopyFeatures32
+typedef struct VkPhysicalDevice8BitStorageFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 hostImageCopy;
-} VkPhysicalDeviceHostImageCopyFeatures32;
-typedef VkPhysicalDeviceHostImageCopyFeatures32 VkPhysicalDeviceHostImageCopyFeaturesEXT32;
+    VkBool32 storageBuffer8BitAccess;
+    VkBool32 uniformAndStorageBuffer8BitAccess;
+    VkBool32 storagePushConstant8;
+} VkPhysicalDevice8BitStorageFeatures32;
+typedef VkPhysicalDevice8BitStorageFeatures32 VkPhysicalDevice8BitStorageFeaturesKHR32;

-typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32
+typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 primitivesGeneratedQuery;
-    VkBool32 primitivesGeneratedQueryWithRasterizerDiscard;
-    VkBool32 primitivesGeneratedQueryWithNonZeroStreams;
-} VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32;
+    VkBool32 decodeModeSharedExponent;
+} VkPhysicalDeviceASTCDecodeFeaturesEXT32;

-typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT32
+typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 legacyDithering;
-} VkPhysicalDeviceLegacyDitheringFeaturesEXT32;
+    VkBool32 accelerationStructure;
+    VkBool32 accelerationStructureCaptureReplay;
+    VkBool32 accelerationStructureIndirectBuild;
+    VkBool32 accelerationStructureHostCommands;
+    VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind;
+} VkPhysicalDeviceAccelerationStructureFeaturesKHR32;

-typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32
+typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 multisampledRenderToSingleSampled;
-} VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32;
+    uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
+    uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
+    uint64_t DECLSPEC_ALIGN(8) maxPrimitiveCount;
+    uint32_t maxPerStageDescriptorAccelerationStructures;
+    uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
+    uint32_t maxDescriptorSetAccelerationStructures;
+    uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures;
+    uint32_t minAccelerationStructureScratchOffsetAlignment;
+} VkPhysicalDeviceAccelerationStructurePropertiesKHR32;

-typedef struct VkPhysicalDevicePipelineProtectedAccessFeatures32
+typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 pipelineProtectedAccess;
-} VkPhysicalDevicePipelineProtectedAccessFeatures32;
-typedef VkPhysicalDevicePipelineProtectedAccessFeatures32 VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32;
+    VkBool32 reportAddressBinding;
+} VkPhysicalDeviceAddressBindingReportFeaturesEXT32;

-typedef struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR32
+typedef struct VkPhysicalDeviceAntiLagFeaturesAMD32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 videoMaintenance1;
-} VkPhysicalDeviceVideoMaintenance1FeaturesKHR32;
+    VkBool32 antiLag;
+} VkPhysicalDeviceAntiLagFeaturesAMD32;

-typedef struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32
+typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 videoDecodeVP9;
-} VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32;
+    VkBool32 attachmentFeedbackLoopDynamicState;
+} VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32;

-typedef struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32
+typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 videoEncodeQuantizationMap;
-} VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32;
+    VkBool32 attachmentFeedbackLoopLayout;
+} VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32;

-typedef struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32
+typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 videoEncodeAV1;
-} VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32;
+    VkBool32 advancedBlendCoherentOperations;
+} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32;

-typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV32
+typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 inheritedViewportScissor2D;
-} VkPhysicalDeviceInheritedViewportScissorFeaturesNV32;
+    uint32_t advancedBlendMaxColorAttachments;
+    VkBool32 advancedBlendIndependentBlend;
+    VkBool32 advancedBlendNonPremultipliedSrcColor;
+    VkBool32 advancedBlendNonPremultipliedDstColor;
+    VkBool32 advancedBlendCorrelatedOverlap;
+    VkBool32 advancedBlendAllOperations;
+} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32;

-typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32
+typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 ycbcr2plane444Formats;
-} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32;
+    VkBool32 borderColorSwizzle;
+    VkBool32 borderColorSwizzleFromImage;
+} VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32;

-typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT32
+typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 provokingVertexLast;
-    VkBool32 transformFeedbackPreservesProvokingVertex;
-} VkPhysicalDeviceProvokingVertexFeaturesEXT32;
+    VkBool32 bufferDeviceAddress;
+    VkBool32 bufferDeviceAddressCaptureReplay;
+    VkBool32 bufferDeviceAddressMultiDevice;
+} VkPhysicalDeviceBufferDeviceAddressFeatures32;
+typedef VkPhysicalDeviceBufferDeviceAddressFeatures32 VkPhysicalDeviceBufferDeviceAddressFeaturesKHR32;

-typedef struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32
+typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 videoEncodeIntraRefresh;
-} VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32;
+    VkBool32 bufferDeviceAddress;
+    VkBool32 bufferDeviceAddressCaptureReplay;
+    VkBool32 bufferDeviceAddressMultiDevice;
+} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32;
+typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 VkPhysicalDeviceBufferAddressFeaturesEXT32;

-typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT32
+typedef struct VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 descriptorBuffer;
-    VkBool32 descriptorBufferCaptureReplay;
-    VkBool32 descriptorBufferImageLayoutIgnored;
-    VkBool32 descriptorBufferPushDescriptors;
-} VkPhysicalDeviceDescriptorBufferFeaturesEXT32;
+    VkBool32 clusterAccelerationStructure;
+} VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32;

-typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures32
+typedef struct VkPhysicalDeviceClusterAccelerationStructurePropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderIntegerDotProduct;
-} VkPhysicalDeviceShaderIntegerDotProductFeatures32;
-typedef VkPhysicalDeviceShaderIntegerDotProductFeatures32 VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR32;
+    uint32_t maxVerticesPerCluster;
+    uint32_t maxTrianglesPerCluster;
+    uint32_t clusterScratchByteAlignment;
+    uint32_t clusterByteAlignment;
+    uint32_t clusterTemplateByteAlignment;
+    uint32_t clusterBottomLevelByteAlignment;
+    uint32_t clusterTemplateBoundsByteAlignment;
+    uint32_t maxClusterGeometryIndex;
+} VkPhysicalDeviceClusterAccelerationStructurePropertiesNV32;

-typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32
+typedef struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 fragmentShaderBarycentric;
-} VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32;
-typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV32;
+    VkBool32 clustercullingShader;
+    VkBool32 multiviewClusterCullingShader;
+} VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32;

-typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32
+typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 rayTracingMotionBlur;
-    VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect;
-} VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32;
+    uint32_t maxWorkGroupCount[3];
+    uint32_t maxWorkGroupSize[3];
+    uint32_t maxOutputClusterCount;
+    VkDeviceSize DECLSPEC_ALIGN(8) indirectBufferOffsetAlignment;
+} VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32;

-typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV32
+typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 rayTracingValidation;
-} VkPhysicalDeviceRayTracingValidationFeaturesNV32;
+    VkBool32 deviceCoherentMemory;
+} VkPhysicalDeviceCoherentMemoryFeaturesAMD32;

-typedef struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV32
+typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 spheres;
-    VkBool32 linearSweptSpheres;
-} VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV32;
+    VkBool32 colorWriteEnable;
+} VkPhysicalDeviceColorWriteEnableFeaturesEXT32;

-typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32
+typedef struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 formatRgba10x6WithoutYCbCrSampler;
-} VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32;
+    VkBool32 commandBufferInheritance;
+} VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32;

-typedef struct VkPhysicalDeviceDynamicRenderingFeatures32
+typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 dynamicRendering;
-} VkPhysicalDeviceDynamicRenderingFeatures32;
-typedef VkPhysicalDeviceDynamicRenderingFeatures32 VkPhysicalDeviceDynamicRenderingFeaturesKHR32;
+    VkBool32 computeDerivativeGroupQuads;
+    VkBool32 computeDerivativeGroupLinear;
+} VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32;
+typedef VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32;

-typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT32
+typedef struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 minLod;
-} VkPhysicalDeviceImageViewMinLodFeaturesEXT32;
+    VkBool32 meshAndTaskShaderDerivatives;
+} VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32;

-typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32
+typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 rasterizationOrderColorAttachmentAccess;
-    VkBool32 rasterizationOrderDepthAttachmentAccess;
-    VkBool32 rasterizationOrderStencilAttachmentAccess;
-} VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32;
-typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM32;
+    VkBool32 conditionalRendering;
+    VkBool32 inheritedConditionalRendering;
+} VkPhysicalDeviceConditionalRenderingFeaturesEXT32;

-typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV32
+typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 linearColorAttachment;
-} VkPhysicalDeviceLinearColorAttachmentFeaturesNV32;
+    float primitiveOverestimationSize;
+    float maxExtraPrimitiveOverestimationSize;
+    float extraPrimitiveOverestimationSizeGranularity;
+    VkBool32 primitiveUnderestimation;
+    VkBool32 conservativePointAndLineRasterization;
+    VkBool32 degenerateTrianglesRasterized;
+    VkBool32 degenerateLinesRasterized;
+    VkBool32 fullyCoveredFragmentShaderInputVariable;
+    VkBool32 conservativeRasterizationPostDepthCoverage;
+} VkPhysicalDeviceConservativeRasterizationPropertiesEXT32;

-typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32
+typedef struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 graphicsPipelineLibrary;
-} VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32;
+    VkBool32 cooperativeMatrixWorkgroupScope;
+    VkBool32 cooperativeMatrixFlexibleDimensions;
+    VkBool32 cooperativeMatrixReductions;
+    VkBool32 cooperativeMatrixConversions;
+    VkBool32 cooperativeMatrixPerElementOperations;
+    VkBool32 cooperativeMatrixTensorAddressing;
+    VkBool32 cooperativeMatrixBlockLoads;
+} VkPhysicalDeviceCooperativeMatrix2FeaturesNV32;

-typedef struct VkPhysicalDevicePipelineBinaryFeaturesKHR32
+typedef struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 pipelineBinaries;
-} VkPhysicalDevicePipelineBinaryFeaturesKHR32;
+    uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize;
+    uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension;
+    uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory;
+} VkPhysicalDeviceCooperativeMatrix2PropertiesNV32;

-typedef struct VkDevicePipelineBinaryInternalCacheControlKHR32
+typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 disableInternalCache;
-} VkDevicePipelineBinaryInternalCacheControlKHR32;
+    VkBool32 cooperativeMatrix;
+    VkBool32 cooperativeMatrixRobustBufferAccess;
+} VkPhysicalDeviceCooperativeMatrixFeaturesKHR32;

-typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32
+typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 descriptorSetHostMapping;
-} VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32;
+    VkBool32 cooperativeMatrix;
+    VkBool32 cooperativeMatrixRobustBufferAccess;
+} VkPhysicalDeviceCooperativeMatrixFeaturesNV32;

-typedef struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT32
+typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 nestedCommandBuffer;
-    VkBool32 nestedCommandBufferRendering;
-    VkBool32 nestedCommandBufferSimultaneousUse;
-} VkPhysicalDeviceNestedCommandBufferFeaturesEXT32;
+    VkShaderStageFlags cooperativeMatrixSupportedStages;
+} VkPhysicalDeviceCooperativeMatrixPropertiesKHR32;

-typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32
+typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderModuleIdentifier;
-} VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32;
+    VkShaderStageFlags cooperativeMatrixSupportedStages;
+} VkPhysicalDeviceCooperativeMatrixPropertiesNV32;

-typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT32
+typedef struct VkPhysicalDeviceCooperativeVectorFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 imageCompressionControl;
-} VkPhysicalDeviceImageCompressionControlFeaturesEXT32;
+    VkBool32 cooperativeVector;
+    VkBool32 cooperativeVectorTraining;
+} VkPhysicalDeviceCooperativeVectorFeaturesNV32;

-typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32
+typedef struct VkPhysicalDeviceCooperativeVectorPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 imageCompressionControlSwapchain;
-} VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32;
+    VkShaderStageFlags cooperativeVectorSupportedStages;
+    VkBool32 cooperativeVectorTrainingFloat16Accumulation;
+    VkBool32 cooperativeVectorTrainingFloat32Accumulation;
+    uint32_t maxCooperativeVectorComponents;
+} VkPhysicalDeviceCooperativeVectorPropertiesNV32;

-typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32
+typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 subpassMergeFeedback;
-} VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32;
+    VkBool32 indirectCopy;
+} VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32;

-typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT32
+typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 micromap;
-    VkBool32 micromapCaptureReplay;
-    VkBool32 micromapHostCommands;
-} VkPhysicalDeviceOpacityMicromapFeaturesEXT32;
+    VkQueueFlags supportedQueues;
+} VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32;

-typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT32
+typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 pipelinePropertiesIdentifier;
-} VkPhysicalDevicePipelinePropertiesFeaturesEXT32;
+    VkBool32 cornerSampledImage;
+} VkPhysicalDeviceCornerSampledImageFeaturesNV32;

-typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32
+typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderEarlyAndLateFragmentTests;
-} VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32;
+    VkBool32 coverageReductionMode;
+} VkPhysicalDeviceCoverageReductionModeFeaturesNV32;

-typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32
+typedef struct VkPhysicalDeviceCubicClampFeaturesQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 nonSeamlessCubeMap;
-} VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32;
+    VkBool32 cubicRangeClamp;
+} VkPhysicalDeviceCubicClampFeaturesQCOM32;

-typedef struct VkPhysicalDevicePipelineRobustnessFeatures32
+typedef struct VkPhysicalDeviceCubicWeightsFeaturesQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 pipelineRobustness;
-} VkPhysicalDevicePipelineRobustnessFeatures32;
-typedef VkPhysicalDevicePipelineRobustnessFeatures32 VkPhysicalDevicePipelineRobustnessFeaturesEXT32;
+    VkBool32 selectableCubicWeights;
+} VkPhysicalDeviceCubicWeightsFeaturesQCOM32;

-typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM32
+typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 textureSampleWeighted;
-    VkBool32 textureBoxFilter;
-    VkBool32 textureBlockMatch;
-} VkPhysicalDeviceImageProcessingFeaturesQCOM32;
+    VkBool32 customBorderColors;
+    VkBool32 customBorderColorWithoutFormat;
+} VkPhysicalDeviceCustomBorderColorFeaturesEXT32;

-typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM32
+typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 tileProperties;
-} VkPhysicalDeviceTilePropertiesFeaturesQCOM32;
+    uint32_t maxCustomBorderColorSamplers;
+} VkPhysicalDeviceCustomBorderColorPropertiesEXT32;

-typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32
+typedef struct VkPhysicalDeviceDataGraphFeaturesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 attachmentFeedbackLoopLayout;
-} VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32;
+    VkBool32 dataGraph;
+    VkBool32 dataGraphUpdateAfterBind;
+    VkBool32 dataGraphSpecializationConstants;
+    VkBool32 dataGraphDescriptorBuffer;
+    VkBool32 dataGraphShaderModule;
+} VkPhysicalDeviceDataGraphFeaturesARM32;

-typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT32
+typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 reportAddressBinding;
-} VkPhysicalDeviceAddressBindingReportFeaturesEXT32;
+    VkBool32 dedicatedAllocationImageAliasing;
+} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32;

-typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV32
+typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 opticalFlow;
-} VkPhysicalDeviceOpticalFlowFeaturesNV32;
+    VkBool32 depthBiasControl;
+    VkBool32 leastRepresentableValueForceUnormRepresentation;
+    VkBool32 floatRepresentation;
+    VkBool32 depthBiasExact;
+} VkPhysicalDeviceDepthBiasControlFeaturesEXT32;

-typedef struct VkPhysicalDeviceFaultFeaturesEXT32
+typedef struct VkPhysicalDeviceDepthClampControlFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 deviceFault;
-    VkBool32 deviceFaultVendorBinary;
-} VkPhysicalDeviceFaultFeaturesEXT32;
+    VkBool32 depthClampControl;
+} VkPhysicalDeviceDepthClampControlFeaturesEXT32;

-typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32
+typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 pipelineLibraryGroupHandles;
-} VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32;
+    VkBool32 depthClampZeroOne;
+} VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32;
+typedef VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32;

-typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32
+typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderCoreBuiltins;
-} VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32;
+    VkBool32 depthClipControl;
+} VkPhysicalDeviceDepthClipControlFeaturesEXT32;

-typedef struct VkPhysicalDeviceFrameBoundaryFeaturesEXT32
+typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 frameBoundary;
-} VkPhysicalDeviceFrameBoundaryFeaturesEXT32;
+    VkBool32 depthClipEnable;
+} VkPhysicalDeviceDepthClipEnableFeaturesEXT32;

-typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32
+typedef struct VkPhysicalDeviceDepthStencilResolveProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 dynamicRenderingUnusedAttachments;
-} VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32;
+    VkResolveModeFlags supportedDepthResolveModes;
+    VkResolveModeFlags supportedStencilResolveModes;
+    VkBool32 independentResolveNone;
+    VkBool32 independentResolve;
+} VkPhysicalDeviceDepthStencilResolveProperties32;
+typedef VkPhysicalDeviceDepthStencilResolveProperties32 VkPhysicalDeviceDepthStencilResolvePropertiesKHR32;

-typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32
+typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 swapchainMaintenance1;
-} VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32;
-typedef VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32;
+    PTR32 combinedImageSamplerDensityMapDescriptorSize;
+} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32;

-typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT32
+typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 depthBiasControl;
-    VkBool32 leastRepresentableValueForceUnormRepresentation;
-    VkBool32 floatRepresentation;
-    VkBool32 depthBiasExact;
-} VkPhysicalDeviceDepthBiasControlFeaturesEXT32;
+    VkBool32 descriptorBuffer;
+    VkBool32 descriptorBufferCaptureReplay;
+    VkBool32 descriptorBufferImageLayoutIgnored;
+    VkBool32 descriptorBufferPushDescriptors;
+} VkPhysicalDeviceDescriptorBufferFeaturesEXT32;

-typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32
+typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 rayTracingInvocationReorder;
-} VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32;
+    VkBool32 combinedImageSamplerDescriptorSingleArray;
+    VkBool32 bufferlessPushDescriptors;
+    VkBool32 allowSamplerImageViewPostSubmitCreation;
+    VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferOffsetAlignment;
+    uint32_t maxDescriptorBufferBindings;
+    uint32_t maxResourceDescriptorBufferBindings;
+    uint32_t maxSamplerDescriptorBufferBindings;
+    uint32_t maxEmbeddedImmutableSamplerBindings;
+    uint32_t maxEmbeddedImmutableSamplers;
+    PTR32 bufferCaptureReplayDescriptorDataSize;
+    PTR32 imageCaptureReplayDescriptorDataSize;
+    PTR32 imageViewCaptureReplayDescriptorDataSize;
+    PTR32 samplerCaptureReplayDescriptorDataSize;
+    PTR32 accelerationStructureCaptureReplayDescriptorDataSize;
+    PTR32 samplerDescriptorSize;
+    PTR32 combinedImageSamplerDescriptorSize;
+    PTR32 sampledImageDescriptorSize;
+    PTR32 storageImageDescriptorSize;
+    PTR32 uniformTexelBufferDescriptorSize;
+    PTR32 robustUniformTexelBufferDescriptorSize;
+    PTR32 storageTexelBufferDescriptorSize;
+    PTR32 robustStorageTexelBufferDescriptorSize;
+    PTR32 uniformBufferDescriptorSize;
+    PTR32 robustUniformBufferDescriptorSize;
+    PTR32 storageBufferDescriptorSize;
+    PTR32 robustStorageBufferDescriptorSize;
+    PTR32 inputAttachmentDescriptorSize;
+    PTR32 accelerationStructureDescriptorSize;
+    VkDeviceSize DECLSPEC_ALIGN(8) maxSamplerDescriptorBufferRange;
+    VkDeviceSize DECLSPEC_ALIGN(8) maxResourceDescriptorBufferRange;
+    VkDeviceSize DECLSPEC_ALIGN(8) samplerDescriptorBufferAddressSpaceSize;
+    VkDeviceSize DECLSPEC_ALIGN(8) resourceDescriptorBufferAddressSpaceSize;
+    VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferAddressSpaceSize;
+} VkPhysicalDeviceDescriptorBufferPropertiesEXT32;

-typedef struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32
+typedef struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 extendedSparseAddressSpace;
-} VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32;
+    VkBool32 descriptorBufferTensorDescriptors;
+} VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32;

-typedef struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32
+typedef struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 multiviewPerViewViewports;
-} VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32;
+    PTR32 tensorCaptureReplayDescriptorDataSize;
+    PTR32 tensorViewCaptureReplayDescriptorDataSize;
+    PTR32 tensorDescriptorSize;
+} VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32;

-typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32
+typedef struct VkPhysicalDeviceDescriptorIndexingFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 rayTracingPositionFetch;
-} VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32;
+    VkBool32 shaderInputAttachmentArrayDynamicIndexing;
+    VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
+    VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
+    VkBool32 shaderUniformBufferArrayNonUniformIndexing;
+    VkBool32 shaderSampledImageArrayNonUniformIndexing;
+    VkBool32 shaderStorageBufferArrayNonUniformIndexing;
+    VkBool32 shaderStorageImageArrayNonUniformIndexing;
+    VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
+    VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
+    VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
+    VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
+    VkBool32 descriptorBindingSampledImageUpdateAfterBind;
+    VkBool32 descriptorBindingStorageImageUpdateAfterBind;
+    VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
+    VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
+    VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
+    VkBool32 descriptorBindingUpdateUnusedWhilePending;
+    VkBool32 descriptorBindingPartiallyBound;
+    VkBool32 descriptorBindingVariableDescriptorCount;
+    VkBool32 runtimeDescriptorArray;
+} VkPhysicalDeviceDescriptorIndexingFeatures32;
+typedef VkPhysicalDeviceDescriptorIndexingFeatures32 VkPhysicalDeviceDescriptorIndexingFeaturesEXT32;

-typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32
+typedef struct VkPhysicalDeviceDescriptorIndexingProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 multiviewPerViewRenderAreas;
-} VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32;
+    uint32_t maxUpdateAfterBindDescriptorsInAllPools;
+    VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
+    VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
+    VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
+    VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
+    VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
+    VkBool32 robustBufferAccessUpdateAfterBind;
+    VkBool32 quadDivergentImplicitLod;
+    uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
+    uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
+    uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    uint32_t maxPerStageUpdateAfterBindResources;
+    uint32_t maxDescriptorSetUpdateAfterBindSamplers;
+    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
+    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
+    uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
+} VkPhysicalDeviceDescriptorIndexingProperties32;
+typedef VkPhysicalDeviceDescriptorIndexingProperties32 VkPhysicalDeviceDescriptorIndexingPropertiesEXT32;

-typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT32
+typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderObject;
-} VkPhysicalDeviceShaderObjectFeaturesEXT32;
+    VkBool32 descriptorPoolOverallocation;
+} VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32;

-typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT32
+typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderTileImageColorReadAccess;
-    VkBool32 shaderTileImageDepthReadAccess;
-    VkBool32 shaderTileImageStencilReadAccess;
-} VkPhysicalDeviceShaderTileImageFeaturesEXT32;
+    VkBool32 descriptorSetHostMapping;
+} VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32;

-typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR32
+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 cooperativeMatrix;
-    VkBool32 cooperativeMatrixRobustBufferAccess;
-} VkPhysicalDeviceCooperativeMatrixFeaturesKHR32;
+    VkBool32 deviceGeneratedCompute;
+    VkBool32 deviceGeneratedComputePipelines;
+    VkBool32 deviceGeneratedComputeCaptureReplay;
+} VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32;

-typedef struct VkPhysicalDeviceAntiLagFeaturesAMD32
+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 antiLag;
-} VkPhysicalDeviceAntiLagFeaturesAMD32;
+    VkBool32 deviceGeneratedCommands;
+    VkBool32 dynamicGeneratedPipelineLayout;
+} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32;

-typedef struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32
+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 tileMemoryHeap;
-} VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32;
+    VkBool32 deviceGeneratedCommands;
+} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32;

-typedef struct VkPhysicalDeviceCubicClampFeaturesQCOM32
+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 cubicRangeClamp;
-} VkPhysicalDeviceCubicClampFeaturesQCOM32;
+    uint32_t maxIndirectPipelineCount;
+    uint32_t maxIndirectShaderObjectCount;
+    uint32_t maxIndirectSequenceCount;
+    uint32_t maxIndirectCommandsTokenCount;
+    uint32_t maxIndirectCommandsTokenOffset;
+    uint32_t maxIndirectCommandsIndirectStride;
+    VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes;
+    VkShaderStageFlags supportedIndirectCommandsShaderStages;
+    VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding;
+    VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding;
+    VkBool32 deviceGeneratedCommandsTransformFeedback;
+    VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount;
+} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32;

-typedef struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32
+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 ycbcrDegamma;
-} VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32;
+    uint32_t maxGraphicsShaderGroupCount;
+    uint32_t maxIndirectSequenceCount;
+    uint32_t maxIndirectCommandsTokenCount;
+    uint32_t maxIndirectCommandsStreamCount;
+    uint32_t maxIndirectCommandsTokenOffset;
+    uint32_t maxIndirectCommandsStreamStride;
+    uint32_t minSequencesCountBufferOffsetAlignment;
+    uint32_t minSequencesIndexBufferOffsetAlignment;
+    uint32_t minIndirectCommandsBufferOffsetAlignment;
+} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32;

-typedef struct VkPhysicalDeviceCubicWeightsFeaturesQCOM32
+typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 selectableCubicWeights;
-} VkPhysicalDeviceCubicWeightsFeaturesQCOM32;
+    VkBool32 diagnosticsConfig;
+} VkPhysicalDeviceDiagnosticsConfigFeaturesNV32;

-typedef struct VkPhysicalDeviceImageProcessing2FeaturesQCOM32
+typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 textureBlockMatch2;
-} VkPhysicalDeviceImageProcessing2FeaturesQCOM32;
+    uint32_t maxDiscardRectangles;
+} VkPhysicalDeviceDiscardRectanglePropertiesEXT32;

-typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32
+typedef struct VkPhysicalDeviceDriverProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 descriptorPoolOverallocation;
-} VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32;
+    VkDriverId driverID;
+    char driverName[VK_MAX_DRIVER_NAME_SIZE];
+    char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
+    VkConformanceVersion conformanceVersion;
+} VkPhysicalDeviceDriverProperties32;
+typedef VkPhysicalDeviceDriverProperties32 VkPhysicalDeviceDriverPropertiesKHR32;

-typedef struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV32
+typedef struct VkPhysicalDeviceDynamicRenderingFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 perStageDescriptorSet;
-    VkBool32 dynamicPipelineLayout;
-} VkPhysicalDevicePerStageDescriptorSetFeaturesNV32;
+    VkBool32 dynamicRendering;
+} VkPhysicalDeviceDynamicRenderingFeatures32;
+typedef VkPhysicalDeviceDynamicRenderingFeatures32 VkPhysicalDeviceDynamicRenderingFeaturesKHR32;

-typedef struct VkPhysicalDeviceSchedulingControlsFeaturesARM32
+typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 schedulingControls;
-} VkPhysicalDeviceSchedulingControlsFeaturesARM32;
+    VkBool32 dynamicRenderingLocalRead;
+} VkPhysicalDeviceDynamicRenderingLocalReadFeatures32;
+typedef VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR32;

-typedef struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32
+typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 relaxedLineRasterization;
-} VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32;
+    VkBool32 dynamicRenderingUnusedAttachments;
+} VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32;

-typedef struct VkPhysicalDeviceRenderPassStripedFeaturesARM32
+typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 renderPassStriped;
-} VkPhysicalDeviceRenderPassStripedFeaturesARM32;
+    VkBool32 exclusiveScissor;
+} VkPhysicalDeviceExclusiveScissorFeaturesNV32;

-typedef struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32
+typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 pipelineOpacityMicromap;
-} VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32;
+    VkBool32 extendedDynamicState2;
+    VkBool32 extendedDynamicState2LogicOp;
+    VkBool32 extendedDynamicState2PatchControlPoints;
+} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32;

-typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32
+typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderMaximalReconvergence;
-} VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32;
+    VkBool32 extendedDynamicState3TessellationDomainOrigin;
+    VkBool32 extendedDynamicState3DepthClampEnable;
+    VkBool32 extendedDynamicState3PolygonMode;
+    VkBool32 extendedDynamicState3RasterizationSamples;
+    VkBool32 extendedDynamicState3SampleMask;
+    VkBool32 extendedDynamicState3AlphaToCoverageEnable;
+    VkBool32 extendedDynamicState3AlphaToOneEnable;
+    VkBool32 extendedDynamicState3LogicOpEnable;
+    VkBool32 extendedDynamicState3ColorBlendEnable;
+    VkBool32 extendedDynamicState3ColorBlendEquation;
+    VkBool32 extendedDynamicState3ColorWriteMask;
+    VkBool32 extendedDynamicState3RasterizationStream;
+    VkBool32 extendedDynamicState3ConservativeRasterizationMode;
+    VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize;
+    VkBool32 extendedDynamicState3DepthClipEnable;
+    VkBool32 extendedDynamicState3SampleLocationsEnable;
+    VkBool32 extendedDynamicState3ColorBlendAdvanced;
+    VkBool32 extendedDynamicState3ProvokingVertexMode;
+    VkBool32 extendedDynamicState3LineRasterizationMode;
+    VkBool32 extendedDynamicState3LineStippleEnable;
+    VkBool32 extendedDynamicState3DepthClipNegativeOneToOne;
+    VkBool32 extendedDynamicState3ViewportWScalingEnable;
+    VkBool32 extendedDynamicState3ViewportSwizzle;
+    VkBool32 extendedDynamicState3CoverageToColorEnable;
+    VkBool32 extendedDynamicState3CoverageToColorLocation;
+    VkBool32 extendedDynamicState3CoverageModulationMode;
+    VkBool32 extendedDynamicState3CoverageModulationTableEnable;
+    VkBool32 extendedDynamicState3CoverageModulationTable;
+    VkBool32 extendedDynamicState3CoverageReductionMode;
+    VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable;
+    VkBool32 extendedDynamicState3ShadingRateImageEnable;
+} VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32;

-typedef struct VkPhysicalDeviceShaderSubgroupRotateFeatures32
+typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderSubgroupRotate;
-    VkBool32 shaderSubgroupRotateClustered;
-} VkPhysicalDeviceShaderSubgroupRotateFeatures32;
-typedef VkPhysicalDeviceShaderSubgroupRotateFeatures32 VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR32;
+    VkBool32 dynamicPrimitiveTopologyUnrestricted;
+} VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32;

-typedef struct VkPhysicalDeviceShaderExpectAssumeFeatures32
+typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderExpectAssume;
-} VkPhysicalDeviceShaderExpectAssumeFeatures32;
-typedef VkPhysicalDeviceShaderExpectAssumeFeatures32 VkPhysicalDeviceShaderExpectAssumeFeaturesKHR32;
+    VkBool32 extendedDynamicState;
+} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32;

-typedef struct VkPhysicalDeviceShaderFloatControls2Features32
+typedef struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderFloatControls2;
-} VkPhysicalDeviceShaderFloatControls2Features32;
-typedef VkPhysicalDeviceShaderFloatControls2Features32 VkPhysicalDeviceShaderFloatControls2FeaturesKHR32;
+    VkBool32 extendedSparseAddressSpace;
+} VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32;

-typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures32
+typedef struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 dynamicRenderingLocalRead;
-} VkPhysicalDeviceDynamicRenderingLocalReadFeatures32;
-typedef VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR32;
+    VkDeviceSize DECLSPEC_ALIGN(8) extendedSparseAddressSpaceSize;
+    VkImageUsageFlags extendedSparseImageUsageFlags;
+    VkBufferUsageFlags extendedSparseBufferUsageFlags;
+} VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV32;

-typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR32
+typedef struct VkPhysicalDeviceExternalBufferInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderQuadControl;
-} VkPhysicalDeviceShaderQuadControlFeaturesKHR32;
+    VkBufferCreateFlags flags;
+    VkBufferUsageFlags usage;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+} VkPhysicalDeviceExternalBufferInfo32;
+typedef VkPhysicalDeviceExternalBufferInfo32 VkPhysicalDeviceExternalBufferInfoKHR32;

-typedef struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32
+typedef struct VkPhysicalDeviceExternalFenceInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderFloat16VectorAtomics;
-} VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32;
+    VkExternalFenceHandleTypeFlagBits handleType;
+} VkPhysicalDeviceExternalFenceInfo32;
+typedef VkPhysicalDeviceExternalFenceInfo32 VkPhysicalDeviceExternalFenceInfoKHR32;

-typedef struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32
+typedef struct VkPhysicalDeviceExternalImageFormatInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 memoryMapPlaced;
-    VkBool32 memoryMapRangePlaced;
-    VkBool32 memoryUnmapReserve;
-} VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+} VkPhysicalDeviceExternalImageFormatInfo32;
+typedef VkPhysicalDeviceExternalImageFormatInfo32 VkPhysicalDeviceExternalImageFormatInfoKHR32;

-typedef struct VkPhysicalDeviceShaderBfloat16FeaturesKHR32
+typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderBFloat16Type;
-    VkBool32 shaderBFloat16DotProduct;
-    VkBool32 shaderBFloat16CooperativeMatrix;
-} VkPhysicalDeviceShaderBfloat16FeaturesKHR32;
+    VkDeviceSize DECLSPEC_ALIGN(8) minImportedHostPointerAlignment;
+} VkPhysicalDeviceExternalMemoryHostPropertiesEXT32;

-typedef struct VkPhysicalDeviceRawAccessChainsFeaturesNV32
+typedef struct VkPhysicalDeviceExternalSemaphoreInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderRawAccessChains;
-} VkPhysicalDeviceRawAccessChainsFeaturesNV32;
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+} VkPhysicalDeviceExternalSemaphoreInfo32;
+typedef VkPhysicalDeviceExternalSemaphoreInfo32 VkPhysicalDeviceExternalSemaphoreInfoKHR32;

-typedef struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32
+typedef struct VkPhysicalDeviceExternalTensorInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 commandBufferInheritance;
-} VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32;
+    VkTensorCreateFlagsARM DECLSPEC_ALIGN(8) flags;
+    PTR32 pDescription;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+} VkPhysicalDeviceExternalTensorInfoARM32;

-typedef struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA32
+typedef struct VkPhysicalDeviceFaultFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 imageAlignmentControl;
-} VkPhysicalDeviceImageAlignmentControlFeaturesMESA32;
+    VkBool32 deviceFault;
+    VkBool32 deviceFaultVendorBinary;
+} VkPhysicalDeviceFaultFeaturesEXT32;

-typedef struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32
+typedef struct VkPhysicalDeviceFeatures232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderReplicatedComposites;
-} VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32;
+    VkPhysicalDeviceFeatures features;
+} VkPhysicalDeviceFeatures232;
+typedef VkPhysicalDeviceFeatures232 VkPhysicalDeviceFeatures2KHR32;

-typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32
+typedef struct VkPhysicalDeviceFloatControlsProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 presentModeFifoLatestReady;
-} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32;
-typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32;
+    VkShaderFloatControlsIndependence denormBehaviorIndependence;
+    VkShaderFloatControlsIndependence roundingModeIndependence;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat16;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat32;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat64;
+    VkBool32 shaderDenormPreserveFloat16;
+    VkBool32 shaderDenormPreserveFloat32;
+    VkBool32 shaderDenormPreserveFloat64;
+    VkBool32 shaderDenormFlushToZeroFloat16;
+    VkBool32 shaderDenormFlushToZeroFloat32;
+    VkBool32 shaderDenormFlushToZeroFloat64;
+    VkBool32 shaderRoundingModeRTEFloat16;
+    VkBool32 shaderRoundingModeRTEFloat32;
+    VkBool32 shaderRoundingModeRTEFloat64;
+    VkBool32 shaderRoundingModeRTZFloat16;
+    VkBool32 shaderRoundingModeRTZFloat32;
+    VkBool32 shaderRoundingModeRTZFloat64;
+} VkPhysicalDeviceFloatControlsProperties32;
+typedef VkPhysicalDeviceFloatControlsProperties32 VkPhysicalDeviceFloatControlsPropertiesKHR32;

-typedef struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV32
+typedef struct VkPhysicalDeviceFormatPackFeaturesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 cooperativeMatrixWorkgroupScope;
-    VkBool32 cooperativeMatrixFlexibleDimensions;
-    VkBool32 cooperativeMatrixReductions;
-    VkBool32 cooperativeMatrixConversions;
-    VkBool32 cooperativeMatrixPerElementOperations;
-    VkBool32 cooperativeMatrixTensorAddressing;
-    VkBool32 cooperativeMatrixBlockLoads;
-} VkPhysicalDeviceCooperativeMatrix2FeaturesNV32;
+    VkBool32 formatPack;
+} VkPhysicalDeviceFormatPackFeaturesARM32;

-typedef struct VkPhysicalDeviceHdrVividFeaturesHUAWEI32
+typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 hdrVivid;
-} VkPhysicalDeviceHdrVividFeaturesHUAWEI32;
+    VkBool32 fragmentDensityMapDeferred;
+} VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32;

-typedef struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32
+typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 vertexAttributeRobustness;
-} VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32;
+    VkBool32 subsampledLoads;
+    VkBool32 subsampledCoarseReconstructionEarlyAccess;
+    uint32_t maxSubsampledArrayLayers;
+    uint32_t maxDescriptorSetSubsampledSamplers;
+} VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32;

-typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32
+typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 depthClampZeroOne;
-} VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32;
-typedef VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32;
+    VkBool32 fragmentDensityMap;
+    VkBool32 fragmentDensityMapDynamic;
+    VkBool32 fragmentDensityMapNonSubsampledImages;
+} VkPhysicalDeviceFragmentDensityMapFeaturesEXT32;

-typedef struct VkPhysicalDeviceCooperativeVectorFeaturesNV32
+typedef struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 cooperativeVector;
-    VkBool32 cooperativeVectorTraining;
-} VkPhysicalDeviceCooperativeVectorFeaturesNV32;
+    VkBool32 fragmentDensityMapLayered;
+} VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32;

-typedef struct VkPhysicalDeviceTileShadingFeaturesQCOM32
+typedef struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 tileShading;
-    VkBool32 tileShadingFragmentStage;
-    VkBool32 tileShadingColorAttachments;
-    VkBool32 tileShadingDepthAttachments;
-    VkBool32 tileShadingStencilAttachments;
-    VkBool32 tileShadingInputAttachments;
-    VkBool32 tileShadingSampledAttachments;
-    VkBool32 tileShadingPerTileDraw;
-    VkBool32 tileShadingPerTileDispatch;
-    VkBool32 tileShadingDispatchTile;
-    VkBool32 tileShadingApron;
-    VkBool32 tileShadingAnisotropicApron;
-    VkBool32 tileShadingAtomicOps;
-    VkBool32 tileShadingImageProcessing;
-} VkPhysicalDeviceTileShadingFeaturesQCOM32;
+    uint32_t maxFragmentDensityMapLayers;
+} VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32;

-typedef struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32
+typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 fragmentDensityMapLayered;
-} VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32;
+    VkBool32 fragmentDensityMapOffset;
+} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32;
+typedef VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32;

-typedef struct VkPhysicalDeviceFormatPackFeaturesARM32
+typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 formatPack;
-} VkPhysicalDeviceFormatPackFeaturesARM32;
+    VkExtent2D fragmentDensityOffsetGranularity;
+} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32;
+typedef VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32 VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32;

-typedef struct VkPhysicalDeviceTensorFeaturesARM32
+typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 tensorNonPacked;
-    VkBool32 shaderTensorAccess;
-    VkBool32 shaderStorageTensorArrayDynamicIndexing;
-    VkBool32 shaderStorageTensorArrayNonUniformIndexing;
-    VkBool32 descriptorBindingStorageTensorUpdateAfterBind;
-    VkBool32 tensors;
-} VkPhysicalDeviceTensorFeaturesARM32;
+    VkExtent2D minFragmentDensityTexelSize;
+    VkExtent2D maxFragmentDensityTexelSize;
+    VkBool32 fragmentDensityInvocations;
+} VkPhysicalDeviceFragmentDensityMapPropertiesEXT32;

-typedef struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32
+typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 descriptorBufferTensorDescriptors;
-} VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32;
+    VkBool32 fragmentShaderBarycentric;
+} VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32;
+typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV32;

-typedef struct VkPhysicalDeviceShaderFloat8FeaturesEXT32
+typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderFloat8;
-    VkBool32 shaderFloat8CooperativeMatrix;
-} VkPhysicalDeviceShaderFloat8FeaturesEXT32;
+    VkBool32 triStripVertexOrderIndependentOfProvokingVertex;
+} VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32;

-typedef struct VkPhysicalDeviceDataGraphFeaturesARM32
+typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 dataGraph;
-    VkBool32 dataGraphUpdateAfterBind;
-    VkBool32 dataGraphSpecializationConstants;
-    VkBool32 dataGraphDescriptorBuffer;
-    VkBool32 dataGraphShaderModule;
-} VkPhysicalDeviceDataGraphFeaturesARM32;
+    VkBool32 fragmentShaderSampleInterlock;
+    VkBool32 fragmentShaderPixelInterlock;
+    VkBool32 fragmentShaderShadingRateInterlock;
+} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32;

-typedef struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32
+typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 pipelineCacheIncrementalMode;
-} VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32;
+    VkBool32 fragmentShadingRateEnums;
+    VkBool32 supersampleFragmentShadingRates;
+    VkBool32 noInvocationFragmentShadingRates;
+} VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32;

-typedef struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32
+typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderUntypedPointers;
-} VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32;
+    VkSampleCountFlagBits maxFragmentShadingRateInvocationCount;
+} VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32;

-typedef struct VkDeviceCreateInfo32
+typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceCreateFlags flags;
-    uint32_t queueCreateInfoCount;
-    PTR32 pQueueCreateInfos;
-    uint32_t enabledLayerCount;
-    PTR32 ppEnabledLayerNames;
-    uint32_t enabledExtensionCount;
-    PTR32 ppEnabledExtensionNames;
-    PTR32 pEnabledFeatures;
-} VkDeviceCreateInfo32;
+    VkBool32 pipelineFragmentShadingRate;
+    VkBool32 primitiveFragmentShadingRate;
+    VkBool32 attachmentFragmentShadingRate;
+} VkPhysicalDeviceFragmentShadingRateFeaturesKHR32;

-typedef struct VkEventCreateInfo32
+typedef struct VkPhysicalDeviceFragmentShadingRateKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkEventCreateFlags flags;
-} VkEventCreateInfo32;
+    VkSampleCountFlags sampleCounts;
+    VkExtent2D fragmentSize;
+} VkPhysicalDeviceFragmentShadingRateKHR32;

-typedef struct VkExportFenceCreateInfo32
+typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalFenceHandleTypeFlags handleTypes;
-} VkExportFenceCreateInfo32;
-typedef VkExportFenceCreateInfo32 VkExportFenceCreateInfoKHR32;
+    VkExtent2D minFragmentShadingRateAttachmentTexelSize;
+    VkExtent2D maxFragmentShadingRateAttachmentTexelSize;
+    uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
+    VkBool32 primitiveFragmentShadingRateWithMultipleViewports;
+    VkBool32 layeredShadingRateAttachments;
+    VkBool32 fragmentShadingRateNonTrivialCombinerOps;
+    VkExtent2D maxFragmentSize;
+    uint32_t maxFragmentSizeAspectRatio;
+    uint32_t maxFragmentShadingRateCoverageSamples;
+    VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples;
+    VkBool32 fragmentShadingRateWithShaderDepthStencilWrites;
+    VkBool32 fragmentShadingRateWithSampleMask;
+    VkBool32 fragmentShadingRateWithShaderSampleMask;
+    VkBool32 fragmentShadingRateWithConservativeRasterization;
+    VkBool32 fragmentShadingRateWithFragmentShaderInterlock;
+    VkBool32 fragmentShadingRateWithCustomSampleLocations;
+    VkBool32 fragmentShadingRateStrictMultiplyCombiner;
+} VkPhysicalDeviceFragmentShadingRatePropertiesKHR32;

-typedef struct VkFenceCreateInfo32
+typedef struct VkPhysicalDeviceFrameBoundaryFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkFenceCreateFlags flags;
-} VkFenceCreateInfo32;
+    VkBool32 frameBoundary;
+} VkPhysicalDeviceFrameBoundaryFeaturesEXT32;

-typedef struct VkFramebufferAttachmentImageInfo32
+typedef struct VkPhysicalDeviceGlobalPriorityQueryFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageCreateFlags flags;
-    VkImageUsageFlags usage;
-    uint32_t width;
-    uint32_t height;
-    uint32_t layerCount;
-    uint32_t viewFormatCount;
-    PTR32 pViewFormats;
-} VkFramebufferAttachmentImageInfo32;
-typedef VkFramebufferAttachmentImageInfo32 VkFramebufferAttachmentImageInfoKHR32;
+    VkBool32 globalPriorityQuery;
+} VkPhysicalDeviceGlobalPriorityQueryFeatures32;
+typedef VkPhysicalDeviceGlobalPriorityQueryFeatures32 VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32;
+typedef VkPhysicalDeviceGlobalPriorityQueryFeatures32 VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT32;

-typedef struct VkFramebufferAttachmentsCreateInfo32
+typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t attachmentImageInfoCount;
-    PTR32 pAttachmentImageInfos;
-} VkFramebufferAttachmentsCreateInfo32;
-typedef VkFramebufferAttachmentsCreateInfo32 VkFramebufferAttachmentsCreateInfoKHR32;
+    VkBool32 graphicsPipelineLibrary;
+} VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32;

-typedef struct VkFramebufferCreateInfo32
+typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkFramebufferCreateFlags flags;
-    VkRenderPass DECLSPEC_ALIGN(8) renderPass;
-    uint32_t attachmentCount;
-    PTR32 pAttachments;
-    uint32_t width;
-    uint32_t height;
-    uint32_t layers;
-} VkFramebufferCreateInfo32;
+    VkBool32 graphicsPipelineLibraryFastLinking;
+    VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration;
+} VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32;

-typedef struct VkPipelineVertexInputDivisorStateCreateInfo32
+typedef struct VkPhysicalDeviceGroupProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t vertexBindingDivisorCount;
-    PTR32 pVertexBindingDivisors;
-} VkPipelineVertexInputDivisorStateCreateInfo32;
-typedef VkPipelineVertexInputDivisorStateCreateInfo32 VkPipelineVertexInputDivisorStateCreateInfoKHR32;
-typedef VkPipelineVertexInputDivisorStateCreateInfo32 VkPipelineVertexInputDivisorStateCreateInfoEXT32;
+    uint32_t physicalDeviceCount;
+    PTR32 physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
+    VkBool32 subsetAllocation;
+} VkPhysicalDeviceGroupProperties32;
+typedef VkPhysicalDeviceGroupProperties32 VkPhysicalDeviceGroupPropertiesKHR32;

-typedef struct VkPipelineVertexInputStateCreateInfo32
+typedef struct VkPhysicalDeviceHdrVividFeaturesHUAWEI32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineVertexInputStateCreateFlags flags;
-    uint32_t vertexBindingDescriptionCount;
-    PTR32 pVertexBindingDescriptions;
-    uint32_t vertexAttributeDescriptionCount;
-    PTR32 pVertexAttributeDescriptions;
-} VkPipelineVertexInputStateCreateInfo32;
+    VkBool32 hdrVivid;
+} VkPhysicalDeviceHdrVividFeaturesHUAWEI32;

-typedef struct VkPipelineTessellationDomainOriginStateCreateInfo32
+typedef struct VkPhysicalDeviceHostImageCopyFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkTessellationDomainOrigin domainOrigin;
-} VkPipelineTessellationDomainOriginStateCreateInfo32;
-typedef VkPipelineTessellationDomainOriginStateCreateInfo32 VkPipelineTessellationDomainOriginStateCreateInfoKHR32;
+    VkBool32 hostImageCopy;
+} VkPhysicalDeviceHostImageCopyFeatures32;
+typedef VkPhysicalDeviceHostImageCopyFeatures32 VkPhysicalDeviceHostImageCopyFeaturesEXT32;

-typedef struct VkPipelineTessellationStateCreateInfo32
+typedef struct VkPhysicalDeviceHostImageCopyProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineTessellationStateCreateFlags flags;
-    uint32_t patchControlPoints;
-} VkPipelineTessellationStateCreateInfo32;
+    uint32_t copySrcLayoutCount;
+    PTR32 pCopySrcLayouts;
+    uint32_t copyDstLayoutCount;
+    PTR32 pCopyDstLayouts;
+    uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE];
+    VkBool32 identicalMemoryTypeRequirements;
+} VkPhysicalDeviceHostImageCopyProperties32;
+typedef VkPhysicalDeviceHostImageCopyProperties32 VkPhysicalDeviceHostImageCopyPropertiesEXT32;

-typedef struct VkGraphicsShaderGroupCreateInfoNV32
+typedef struct VkPhysicalDeviceHostQueryResetFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t stageCount;
-    PTR32 pStages;
-    PTR32 pVertexInputState;
-    PTR32 pTessellationState;
-} VkGraphicsShaderGroupCreateInfoNV32;
+    VkBool32 hostQueryReset;
+} VkPhysicalDeviceHostQueryResetFeatures32;
+typedef VkPhysicalDeviceHostQueryResetFeatures32 VkPhysicalDeviceHostQueryResetFeaturesEXT32;

-typedef struct VkPipelineInputAssemblyStateCreateInfo32
+typedef struct VkPhysicalDeviceIDProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineInputAssemblyStateCreateFlags flags;
-    VkPrimitiveTopology topology;
-    VkBool32 primitiveRestartEnable;
-} VkPipelineInputAssemblyStateCreateInfo32;
+    uint8_t deviceUUID[VK_UUID_SIZE];
+    uint8_t driverUUID[VK_UUID_SIZE];
+    uint8_t deviceLUID[VK_LUID_SIZE];
+    uint32_t deviceNodeMask;
+    VkBool32 deviceLUIDValid;
+} VkPhysicalDeviceIDProperties32;
+typedef VkPhysicalDeviceIDProperties32 VkPhysicalDeviceIDPropertiesKHR32;

-typedef struct VkPipelineViewportWScalingStateCreateInfoNV32
+typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 viewportWScalingEnable;
-    uint32_t viewportCount;
-    PTR32 pViewportWScalings;
-} VkPipelineViewportWScalingStateCreateInfoNV32;
+    VkBool32 image2DViewOf3D;
+    VkBool32 sampler2DViewOf3D;
+} VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32;

-typedef struct VkPipelineViewportSwizzleStateCreateInfoNV32
+typedef struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineViewportSwizzleStateCreateFlagsNV flags;
-    uint32_t viewportCount;
-    PTR32 pViewportSwizzles;
-} VkPipelineViewportSwizzleStateCreateInfoNV32;
+    VkBool32 imageAlignmentControl;
+} VkPhysicalDeviceImageAlignmentControlFeaturesMESA32;

-typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV32
+typedef struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t exclusiveScissorCount;
-    PTR32 pExclusiveScissors;
-} VkPipelineViewportExclusiveScissorStateCreateInfoNV32;
+    uint32_t supportedImageAlignmentMask;
+} VkPhysicalDeviceImageAlignmentControlPropertiesMESA32;

-typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV32
+typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shadingRateImageEnable;
-    uint32_t viewportCount;
-    PTR32 pShadingRatePalettes;
-} VkPipelineViewportShadingRateImageStateCreateInfoNV32;
+    VkBool32 imageCompressionControl;
+} VkPhysicalDeviceImageCompressionControlFeaturesEXT32;

-typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32
+typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkCoarseSampleOrderTypeNV sampleOrderType;
-    uint32_t customSampleOrderCount;
-    PTR32 pCustomSampleOrders;
-} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32;
+    VkBool32 imageCompressionControlSwapchain;
+} VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32;

-typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT32
+typedef struct VkPhysicalDeviceImageFormatInfo232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 negativeOneToOne;
-} VkPipelineViewportDepthClipControlCreateInfoEXT32;
+    VkFormat format;
+    VkImageType type;
+    VkImageTiling tiling;
+    VkImageUsageFlags usage;
+    VkImageCreateFlags flags;
+} VkPhysicalDeviceImageFormatInfo232;
+typedef VkPhysicalDeviceImageFormatInfo232 VkPhysicalDeviceImageFormatInfo2KHR32;

-typedef struct VkPipelineViewportDepthClampControlCreateInfoEXT32
+typedef struct VkPhysicalDeviceImageProcessing2FeaturesQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDepthClampModeEXT depthClampMode;
-    PTR32 pDepthClampRange;
-} VkPipelineViewportDepthClampControlCreateInfoEXT32;
+    VkBool32 textureBlockMatch2;
+} VkPhysicalDeviceImageProcessing2FeaturesQCOM32;

-typedef struct VkPipelineViewportStateCreateInfo32
+typedef struct VkPhysicalDeviceImageProcessing2PropertiesQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineViewportStateCreateFlags flags;
-    uint32_t viewportCount;
-    PTR32 pViewports;
-    uint32_t scissorCount;
-    PTR32 pScissors;
-} VkPipelineViewportStateCreateInfo32;
+    VkExtent2D maxBlockMatchWindow;
+} VkPhysicalDeviceImageProcessing2PropertiesQCOM32;

-typedef struct VkPipelineRasterizationStateRasterizationOrderAMD32
+typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkRasterizationOrderAMD rasterizationOrder;
-} VkPipelineRasterizationStateRasterizationOrderAMD32;
+    VkBool32 textureSampleWeighted;
+    VkBool32 textureBoxFilter;
+    VkBool32 textureBlockMatch;
+} VkPhysicalDeviceImageProcessingFeaturesQCOM32;

-typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT32
+typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
-    VkConservativeRasterizationModeEXT conservativeRasterizationMode;
-    float extraPrimitiveOverestimationSize;
-} VkPipelineRasterizationConservativeStateCreateInfoEXT32;
+    uint32_t maxWeightFilterPhases;
+    VkExtent2D maxWeightFilterDimension;
+    VkExtent2D maxBlockMatchRegion;
+    VkExtent2D maxBoxFilterBlockSize;
+} VkPhysicalDeviceImageProcessingPropertiesQCOM32;

-typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT32
+typedef struct VkPhysicalDeviceImageRobustnessFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineRasterizationStateStreamCreateFlagsEXT flags;
-    uint32_t rasterizationStream;
-} VkPipelineRasterizationStateStreamCreateInfoEXT32;
+    VkBool32 robustImageAccess;
+} VkPhysicalDeviceImageRobustnessFeatures32;
+typedef VkPhysicalDeviceImageRobustnessFeatures32 VkPhysicalDeviceImageRobustnessFeaturesEXT32;

-typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT32
+typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags;
-    VkBool32 depthClipEnable;
-} VkPipelineRasterizationDepthClipStateCreateInfoEXT32;
+    VkBool32 imageSlicedViewOf3D;
+} VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32;

-typedef struct VkPipelineRasterizationLineStateCreateInfo32
+typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkLineRasterizationMode lineRasterizationMode;
-    VkBool32 stippledLineEnable;
-    uint32_t lineStippleFactor;
-    uint16_t lineStipplePattern;
-} VkPipelineRasterizationLineStateCreateInfo32;
-typedef VkPipelineRasterizationLineStateCreateInfo32 VkPipelineRasterizationLineStateCreateInfoKHR32;
-typedef VkPipelineRasterizationLineStateCreateInfo32 VkPipelineRasterizationLineStateCreateInfoEXT32;
+    VkImageViewType imageViewType;
+} VkPhysicalDeviceImageViewImageFormatInfoEXT32;

-typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32
+typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkProvokingVertexModeEXT provokingVertexMode;
-} VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32;
+    VkBool32 minLod;
+} VkPhysicalDeviceImageViewMinLodFeaturesEXT32;

-typedef struct VkPipelineRasterizationStateCreateInfo32
+typedef struct VkPhysicalDeviceImagelessFramebufferFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineRasterizationStateCreateFlags flags;
-    VkBool32 depthClampEnable;
-    VkBool32 rasterizerDiscardEnable;
-    VkPolygonMode polygonMode;
-    VkCullModeFlags cullMode;
-    VkFrontFace frontFace;
-    VkBool32 depthBiasEnable;
-    float depthBiasConstantFactor;
-    float depthBiasClamp;
-    float depthBiasSlopeFactor;
-    float lineWidth;
-} VkPipelineRasterizationStateCreateInfo32;
+    VkBool32 imagelessFramebuffer;
+} VkPhysicalDeviceImagelessFramebufferFeatures32;
+typedef VkPhysicalDeviceImagelessFramebufferFeatures32 VkPhysicalDeviceImagelessFramebufferFeaturesKHR32;

-typedef struct VkPipelineCoverageToColorStateCreateInfoNV32
+typedef struct VkPhysicalDeviceIndexTypeUint8Features32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineCoverageToColorStateCreateFlagsNV flags;
-    VkBool32 coverageToColorEnable;
-    uint32_t coverageToColorLocation;
-} VkPipelineCoverageToColorStateCreateInfoNV32;
+    VkBool32 indexTypeUint8;
+} VkPhysicalDeviceIndexTypeUint8Features32;
+typedef VkPhysicalDeviceIndexTypeUint8Features32 VkPhysicalDeviceIndexTypeUint8FeaturesKHR32;
+typedef VkPhysicalDeviceIndexTypeUint8Features32 VkPhysicalDeviceIndexTypeUint8FeaturesEXT32;

-typedef struct VkPipelineSampleLocationsStateCreateInfoEXT32
+typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 sampleLocationsEnable;
-    VkSampleLocationsInfoEXT32 sampleLocationsInfo;
-} VkPipelineSampleLocationsStateCreateInfoEXT32;
+    VkBool32 inheritedViewportScissor2D;
+} VkPhysicalDeviceInheritedViewportScissorFeaturesNV32;

-typedef struct VkPipelineCoverageModulationStateCreateInfoNV32
+typedef struct VkPhysicalDeviceInlineUniformBlockFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineCoverageModulationStateCreateFlagsNV flags;
-    VkCoverageModulationModeNV coverageModulationMode;
-    VkBool32 coverageModulationTableEnable;
-    uint32_t coverageModulationTableCount;
-    PTR32 pCoverageModulationTable;
-} VkPipelineCoverageModulationStateCreateInfoNV32;
+    VkBool32 inlineUniformBlock;
+    VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
+} VkPhysicalDeviceInlineUniformBlockFeatures32;
+typedef VkPhysicalDeviceInlineUniformBlockFeatures32 VkPhysicalDeviceInlineUniformBlockFeaturesEXT32;

-typedef struct VkPipelineCoverageReductionStateCreateInfoNV32
+typedef struct VkPhysicalDeviceInlineUniformBlockProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineCoverageReductionStateCreateFlagsNV flags;
-    VkCoverageReductionModeNV coverageReductionMode;
-} VkPipelineCoverageReductionStateCreateInfoNV32;
+    uint32_t maxInlineUniformBlockSize;
+    uint32_t maxPerStageDescriptorInlineUniformBlocks;
+    uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    uint32_t maxDescriptorSetInlineUniformBlocks;
+    uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+} VkPhysicalDeviceInlineUniformBlockProperties32;
+typedef VkPhysicalDeviceInlineUniformBlockProperties32 VkPhysicalDeviceInlineUniformBlockPropertiesEXT32;

-typedef struct VkPipelineMultisampleStateCreateInfo32
+typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineMultisampleStateCreateFlags flags;
-    VkSampleCountFlagBits rasterizationSamples;
-    VkBool32 sampleShadingEnable;
-    float minSampleShading;
-    PTR32 pSampleMask;
-    VkBool32 alphaToCoverageEnable;
-    VkBool32 alphaToOneEnable;
-} VkPipelineMultisampleStateCreateInfo32;
+    VkBool32 invocationMask;
+} VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32;

-typedef struct VkPipelineDepthStencilStateCreateInfo32
+typedef struct VkPhysicalDeviceLayeredDriverPropertiesMSFT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineDepthStencilStateCreateFlags flags;
-    VkBool32 depthTestEnable;
-    VkBool32 depthWriteEnable;
-    VkCompareOp depthCompareOp;
-    VkBool32 depthBoundsTestEnable;
-    VkBool32 stencilTestEnable;
-    VkStencilOpState front;
-    VkStencilOpState back;
-    float minDepthBounds;
-    float maxDepthBounds;
-} VkPipelineDepthStencilStateCreateInfo32;
+    VkLayeredDriverUnderlyingApiMSFT underlyingAPI;
+} VkPhysicalDeviceLayeredDriverPropertiesMSFT32;

-typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT32
+typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 srcPremultiplied;
-    VkBool32 dstPremultiplied;
-    VkBlendOverlapEXT blendOverlap;
-} VkPipelineColorBlendAdvancedStateCreateInfoEXT32;
+    VkBool32 legacyDithering;
+} VkPhysicalDeviceLegacyDitheringFeaturesEXT32;

-typedef struct VkPipelineColorWriteCreateInfoEXT32
+typedef struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t attachmentCount;
-    PTR32 pColorWriteEnables;
-} VkPipelineColorWriteCreateInfoEXT32;
+    VkBool32 legacyVertexAttributes;
+} VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32;

-typedef struct VkPipelineColorBlendStateCreateInfo32
+typedef struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineColorBlendStateCreateFlags flags;
-    VkBool32 logicOpEnable;
-    VkLogicOp logicOp;
-    uint32_t attachmentCount;
-    PTR32 pAttachments;
-    float blendConstants[4];
-} VkPipelineColorBlendStateCreateInfo32;
+    VkBool32 nativeUnalignedPerformance;
+} VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32;

-typedef struct VkPipelineDynamicStateCreateInfo32
+typedef struct VkPhysicalDeviceLineRasterizationFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineDynamicStateCreateFlags flags;
-    uint32_t dynamicStateCount;
-    PTR32 pDynamicStates;
-} VkPipelineDynamicStateCreateInfo32;
+    VkBool32 rectangularLines;
+    VkBool32 bresenhamLines;
+    VkBool32 smoothLines;
+    VkBool32 stippledRectangularLines;
+    VkBool32 stippledBresenhamLines;
+    VkBool32 stippledSmoothLines;
+} VkPhysicalDeviceLineRasterizationFeatures32;
+typedef VkPhysicalDeviceLineRasterizationFeatures32 VkPhysicalDeviceLineRasterizationFeaturesKHR32;
+typedef VkPhysicalDeviceLineRasterizationFeatures32 VkPhysicalDeviceLineRasterizationFeaturesEXT32;

-typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV32
+typedef struct VkPhysicalDeviceLineRasterizationProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t groupCount;
-    PTR32 pGroups;
-    uint32_t pipelineCount;
-    PTR32 pPipelines;
-} VkGraphicsPipelineShaderGroupsCreateInfoNV32;
+    uint32_t lineSubPixelPrecisionBits;
+} VkPhysicalDeviceLineRasterizationProperties32;
+typedef VkPhysicalDeviceLineRasterizationProperties32 VkPhysicalDeviceLineRasterizationPropertiesKHR32;
+typedef VkPhysicalDeviceLineRasterizationProperties32 VkPhysicalDeviceLineRasterizationPropertiesEXT32;

-typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT32
+typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineDiscardRectangleStateCreateFlagsEXT flags;
-    VkDiscardRectangleModeEXT discardRectangleMode;
-    uint32_t discardRectangleCount;
-    PTR32 pDiscardRectangles;
-} VkPipelineDiscardRectangleStateCreateInfoEXT32;
+    VkBool32 linearColorAttachment;
+} VkPhysicalDeviceLinearColorAttachmentFeaturesNV32;

-typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV32
+typedef struct VkPhysicalDeviceMaintenance3Properties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 representativeFragmentTestEnable;
-} VkPipelineRepresentativeFragmentTestStateCreateInfoNV32;
+    uint32_t maxPerSetDescriptors;
+    VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
+} VkPhysicalDeviceMaintenance3Properties32;
+typedef VkPhysicalDeviceMaintenance3Properties32 VkPhysicalDeviceMaintenance3PropertiesKHR32;

-typedef struct VkPipelineLibraryCreateInfoKHR32
+typedef struct VkPhysicalDeviceMaintenance4Features32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t libraryCount;
-    PTR32 pLibraries;
-} VkPipelineLibraryCreateInfoKHR32;
+    VkBool32 maintenance4;
+} VkPhysicalDeviceMaintenance4Features32;
+typedef VkPhysicalDeviceMaintenance4Features32 VkPhysicalDeviceMaintenance4FeaturesKHR32;

-typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR32
+typedef struct VkPhysicalDeviceMaintenance4Properties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExtent2D fragmentSize;
-    VkFragmentShadingRateCombinerOpKHR combinerOps[2];
-} VkPipelineFragmentShadingRateStateCreateInfoKHR32;
+    VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
+} VkPhysicalDeviceMaintenance4Properties32;
+typedef VkPhysicalDeviceMaintenance4Properties32 VkPhysicalDeviceMaintenance4PropertiesKHR32;

-typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV32
+typedef struct VkPhysicalDeviceMaintenance5Features32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkFragmentShadingRateTypeNV shadingRateType;
-    VkFragmentShadingRateNV shadingRate;
-    VkFragmentShadingRateCombinerOpKHR combinerOps[2];
-} VkPipelineFragmentShadingRateEnumStateCreateInfoNV32;
+    VkBool32 maintenance5;
+} VkPhysicalDeviceMaintenance5Features32;
+typedef VkPhysicalDeviceMaintenance5Features32 VkPhysicalDeviceMaintenance5FeaturesKHR32;

-typedef struct VkPipelineRenderingCreateInfo32
+typedef struct VkPhysicalDeviceMaintenance5Properties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t viewMask;
-    uint32_t colorAttachmentCount;
-    PTR32 pColorAttachmentFormats;
-    VkFormat depthAttachmentFormat;
-    VkFormat stencilAttachmentFormat;
-} VkPipelineRenderingCreateInfo32;
-typedef VkPipelineRenderingCreateInfo32 VkPipelineRenderingCreateInfoKHR32;
+    VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting;
+    VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting;
+    VkBool32 depthStencilSwizzleOneSupport;
+    VkBool32 polygonModePointSize;
+    VkBool32 nonStrictSinglePixelWideLinesUseParallelogram;
+    VkBool32 nonStrictWideLinesUseParallelogram;
+} VkPhysicalDeviceMaintenance5Properties32;
+typedef VkPhysicalDeviceMaintenance5Properties32 VkPhysicalDeviceMaintenance5PropertiesKHR32;

-typedef struct VkGraphicsPipelineLibraryCreateInfoEXT32
+typedef struct VkPhysicalDeviceMaintenance6Features32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkGraphicsPipelineLibraryFlagsEXT flags;
-} VkGraphicsPipelineLibraryCreateInfoEXT32;
+    VkBool32 maintenance6;
+} VkPhysicalDeviceMaintenance6Features32;
+typedef VkPhysicalDeviceMaintenance6Features32 VkPhysicalDeviceMaintenance6FeaturesKHR32;

-typedef struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32
+typedef struct VkPhysicalDeviceMaintenance6Properties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxFragmentDensityMapLayers;
-} VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32;
+    VkBool32 blockTexelViewCompatibleMultipleLayers;
+    uint32_t maxCombinedImageSamplerDescriptorCount;
+    VkBool32 fragmentShadingRateClampCombinerInputs;
+} VkPhysicalDeviceMaintenance6Properties32;
+typedef VkPhysicalDeviceMaintenance6Properties32 VkPhysicalDeviceMaintenance6PropertiesKHR32;

-typedef struct VkGraphicsPipelineCreateInfo32
+typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineCreateFlags flags;
-    uint32_t stageCount;
-    PTR32 pStages;
-    PTR32 pVertexInputState;
-    PTR32 pInputAssemblyState;
-    PTR32 pTessellationState;
-    PTR32 pViewportState;
-    PTR32 pRasterizationState;
-    PTR32 pMultisampleState;
-    PTR32 pDepthStencilState;
-    PTR32 pColorBlendState;
-    PTR32 pDynamicState;
-    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
-    VkRenderPass DECLSPEC_ALIGN(8) renderPass;
-    uint32_t subpass;
-    VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
-    int32_t basePipelineIndex;
-} VkGraphicsPipelineCreateInfo32;
+    VkBool32 maintenance8;
+} VkPhysicalDeviceMaintenance8FeaturesKHR32;

-typedef struct VkDedicatedAllocationImageCreateInfoNV32
+typedef struct VkPhysicalDeviceMaintenance9FeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 dedicatedAllocation;
-} VkDedicatedAllocationImageCreateInfoNV32;
+    VkBool32 maintenance9;
+} VkPhysicalDeviceMaintenance9FeaturesKHR32;

-typedef struct VkExternalMemoryImageCreateInfo32
+typedef struct VkPhysicalDeviceMaintenance9PropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalMemoryHandleTypeFlags handleTypes;
-} VkExternalMemoryImageCreateInfo32;
-typedef VkExternalMemoryImageCreateInfo32 VkExternalMemoryImageCreateInfoKHR32;
+    VkBool32 image2DViewOf3DSparse;
+    VkDefaultVertexAttributeValueKHR defaultVertexAttributeValue;
+} VkPhysicalDeviceMaintenance9PropertiesKHR32;

-typedef struct VkImageSwapchainCreateInfoKHR32
+typedef struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
-} VkImageSwapchainCreateInfoKHR32;
+    VkBool32 memoryMapPlaced;
+    VkBool32 memoryMapRangePlaced;
+    VkBool32 memoryUnmapReserve;
+} VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32;

-typedef struct VkImageFormatListCreateInfo32
+typedef struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t viewFormatCount;
-    PTR32 pViewFormats;
-} VkImageFormatListCreateInfo32;
-typedef VkImageFormatListCreateInfo32 VkImageFormatListCreateInfoKHR32;
+    VkDeviceSize DECLSPEC_ALIGN(8) minPlacedMemoryMapAlignment;
+} VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32;

-typedef struct VkImageStencilUsageCreateInfo32
+typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageUsageFlags stencilUsage;
-} VkImageStencilUsageCreateInfo32;
-typedef VkImageStencilUsageCreateInfo32 VkImageStencilUsageCreateInfoEXT32;
+    VkDeviceSize DECLSPEC_ALIGN(8) heapBudget[VK_MAX_MEMORY_HEAPS];
+    VkDeviceSize DECLSPEC_ALIGN(8) heapUsage[VK_MAX_MEMORY_HEAPS];
+} VkPhysicalDeviceMemoryBudgetPropertiesEXT32;

-typedef struct VkImageCompressionControlEXT32
+typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageCompressionFlagsEXT flags;
-    uint32_t compressionControlPlaneCount;
-    PTR32 pFixedRateFlags;
-} VkImageCompressionControlEXT32;
+    VkBool32 memoryDecompression;
+} VkPhysicalDeviceMemoryDecompressionFeaturesNV32;

-typedef struct VkOpticalFlowImageFormatInfoNV32
+typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkOpticalFlowUsageFlagsNV usage;
-} VkOpticalFlowImageFormatInfoNV32;
+    VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethods;
+    uint64_t DECLSPEC_ALIGN(8) maxDecompressionIndirectCount;
+} VkPhysicalDeviceMemoryDecompressionPropertiesNV32;

-typedef struct VkImageAlignmentControlCreateInfoMESA32
+typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maximumRequestedAlignment;
-} VkImageAlignmentControlCreateInfoMESA32;
+    VkBool32 memoryPriority;
+} VkPhysicalDeviceMemoryPriorityFeaturesEXT32;

-typedef struct VkImageCreateInfo32
+typedef struct VkPhysicalDeviceMemoryProperties232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageCreateFlags flags;
-    VkImageType imageType;
-    VkFormat format;
-    VkExtent3D extent;
-    uint32_t mipLevels;
-    uint32_t arrayLayers;
-    VkSampleCountFlagBits samples;
-    VkImageTiling tiling;
-    VkImageUsageFlags usage;
-    VkSharingMode sharingMode;
-    uint32_t queueFamilyIndexCount;
-    PTR32 pQueueFamilyIndices;
-    VkImageLayout initialLayout;
-} VkImageCreateInfo32;
+    VkPhysicalDeviceMemoryProperties32 DECLSPEC_ALIGN(8) memoryProperties;
+} VkPhysicalDeviceMemoryProperties232;
+typedef VkPhysicalDeviceMemoryProperties232 VkPhysicalDeviceMemoryProperties2KHR32;

-typedef struct VkImageViewUsageCreateInfo32
+typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageUsageFlags usage;
-} VkImageViewUsageCreateInfo32;
-typedef VkImageViewUsageCreateInfo32 VkImageViewUsageCreateInfoKHR32;
+    VkBool32 taskShader;
+    VkBool32 meshShader;
+    VkBool32 multiviewMeshShader;
+    VkBool32 primitiveFragmentShadingRateMeshShader;
+    VkBool32 meshShaderQueries;
+} VkPhysicalDeviceMeshShaderFeaturesEXT32;

-typedef struct VkImageViewSlicedCreateInfoEXT32
+typedef struct VkPhysicalDeviceMeshShaderFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t sliceOffset;
-    uint32_t sliceCount;
-} VkImageViewSlicedCreateInfoEXT32;
+    VkBool32 taskShader;
+    VkBool32 meshShader;
+} VkPhysicalDeviceMeshShaderFeaturesNV32;

-typedef struct VkSamplerYcbcrConversionInfo32
+typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) conversion;
-} VkSamplerYcbcrConversionInfo32;
-typedef VkSamplerYcbcrConversionInfo32 VkSamplerYcbcrConversionInfoKHR32;
+    uint32_t maxTaskWorkGroupTotalCount;
+    uint32_t maxTaskWorkGroupCount[3];
+    uint32_t maxTaskWorkGroupInvocations;
+    uint32_t maxTaskWorkGroupSize[3];
+    uint32_t maxTaskPayloadSize;
+    uint32_t maxTaskSharedMemorySize;
+    uint32_t maxTaskPayloadAndSharedMemorySize;
+    uint32_t maxMeshWorkGroupTotalCount;
+    uint32_t maxMeshWorkGroupCount[3];
+    uint32_t maxMeshWorkGroupInvocations;
+    uint32_t maxMeshWorkGroupSize[3];
+    uint32_t maxMeshSharedMemorySize;
+    uint32_t maxMeshPayloadAndSharedMemorySize;
+    uint32_t maxMeshOutputMemorySize;
+    uint32_t maxMeshPayloadAndOutputMemorySize;
+    uint32_t maxMeshOutputComponents;
+    uint32_t maxMeshOutputVertices;
+    uint32_t maxMeshOutputPrimitives;
+    uint32_t maxMeshOutputLayers;
+    uint32_t maxMeshMultiviewViewCount;
+    uint32_t meshOutputPerVertexGranularity;
+    uint32_t meshOutputPerPrimitiveGranularity;
+    uint32_t maxPreferredTaskWorkGroupInvocations;
+    uint32_t maxPreferredMeshWorkGroupInvocations;
+    VkBool32 prefersLocalInvocationVertexOutput;
+    VkBool32 prefersLocalInvocationPrimitiveOutput;
+    VkBool32 prefersCompactVertexOutput;
+    VkBool32 prefersCompactPrimitiveOutput;
+} VkPhysicalDeviceMeshShaderPropertiesEXT32;

-typedef struct VkImageViewASTCDecodeModeEXT32
+typedef struct VkPhysicalDeviceMeshShaderPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkFormat decodeMode;
-} VkImageViewASTCDecodeModeEXT32;
+    uint32_t maxDrawMeshTasksCount;
+    uint32_t maxTaskWorkGroupInvocations;
+    uint32_t maxTaskWorkGroupSize[3];
+    uint32_t maxTaskTotalMemorySize;
+    uint32_t maxTaskOutputCount;
+    uint32_t maxMeshWorkGroupInvocations;
+    uint32_t maxMeshWorkGroupSize[3];
+    uint32_t maxMeshTotalMemorySize;
+    uint32_t maxMeshOutputVertices;
+    uint32_t maxMeshOutputPrimitives;
+    uint32_t maxMeshMultiviewViewCount;
+    uint32_t meshOutputPerVertexGranularity;
+    uint32_t meshOutputPerPrimitiveGranularity;
+} VkPhysicalDeviceMeshShaderPropertiesNV32;

-typedef struct VkImageViewMinLodCreateInfoEXT32
+typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    float minLod;
-} VkImageViewMinLodCreateInfoEXT32;
+    VkBool32 multiDraw;
+} VkPhysicalDeviceMultiDrawFeaturesEXT32;

-typedef struct VkImageViewSampleWeightCreateInfoQCOM32
+typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkOffset2D filterCenter;
-    VkExtent2D filterSize;
-    uint32_t numPhases;
-} VkImageViewSampleWeightCreateInfoQCOM32;
+    uint32_t maxMultiDrawCount;
+} VkPhysicalDeviceMultiDrawPropertiesEXT32;

-typedef struct VkImageViewCreateInfo32
+typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageViewCreateFlags flags;
-    VkImage DECLSPEC_ALIGN(8) image;
-    VkImageViewType viewType;
-    VkFormat format;
-    VkComponentMapping components;
-    VkImageSubresourceRange subresourceRange;
-} VkImageViewCreateInfo32;
+    VkBool32 multisampledRenderToSingleSampled;
+} VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32;

-typedef union VkIndirectCommandsTokenDataEXT32
+typedef struct VkPhysicalDeviceMultiviewFeatures32
 {
-    PTR32 pPushConstant;
-    PTR32 pVertexBuffer;
-    PTR32 pIndexBuffer;
-    PTR32 pExecutionSet;
-} VkIndirectCommandsTokenDataEXT32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 multiview;
+    VkBool32 multiviewGeometryShader;
+    VkBool32 multiviewTessellationShader;
+} VkPhysicalDeviceMultiviewFeatures32;
+typedef VkPhysicalDeviceMultiviewFeatures32 VkPhysicalDeviceMultiviewFeaturesKHR32;

-typedef struct VkIndirectCommandsLayoutTokenEXT32
+typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkIndirectCommandsTokenTypeEXT type;
-    VkIndirectCommandsTokenDataEXT32 data;
-    uint32_t offset;
-} VkIndirectCommandsLayoutTokenEXT32;
+    VkBool32 multiviewPerViewRenderAreas;
+} VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32;

-typedef struct VkIndirectCommandsLayoutCreateInfoEXT32
+typedef struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkIndirectCommandsLayoutUsageFlagsEXT flags;
-    VkShaderStageFlags shaderStages;
-    uint32_t indirectStride;
-    VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
-    uint32_t tokenCount;
-    PTR32 pTokens;
-} VkIndirectCommandsLayoutCreateInfoEXT32;
+    VkBool32 multiviewPerViewViewports;
+} VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32;

-typedef struct VkIndirectCommandsLayoutTokenNV32
+typedef struct VkPhysicalDeviceMultiviewProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkIndirectCommandsTokenTypeNV tokenType;
-    uint32_t stream;
-    uint32_t offset;
-    uint32_t vertexBindingUnit;
-    VkBool32 vertexDynamicStride;
-    VkPipelineLayout DECLSPEC_ALIGN(8) pushconstantPipelineLayout;
-    VkShaderStageFlags pushconstantShaderStageFlags;
-    uint32_t pushconstantOffset;
-    uint32_t pushconstantSize;
-    VkIndirectStateFlagsNV indirectStateFlags;
-    uint32_t indexTypeCount;
-    PTR32 pIndexTypes;
-    PTR32 pIndexTypeValues;
-} VkIndirectCommandsLayoutTokenNV32;
+    uint32_t maxMultiviewViewCount;
+    uint32_t maxMultiviewInstanceIndex;
+} VkPhysicalDeviceMultiviewProperties32;
+typedef VkPhysicalDeviceMultiviewProperties32 VkPhysicalDeviceMultiviewPropertiesKHR32;

-typedef struct VkIndirectCommandsLayoutCreateInfoNV32
+typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkIndirectCommandsLayoutUsageFlagsNV flags;
-    VkPipelineBindPoint pipelineBindPoint;
-    uint32_t tokenCount;
-    PTR32 pTokens;
-    uint32_t streamCount;
-    PTR32 pStreamStrides;
-} VkIndirectCommandsLayoutCreateInfoNV32;
+    VkBool32 mutableDescriptorType;
+} VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32;
+typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE32;

-typedef struct VkIndirectExecutionSetPipelineInfoEXT32
+typedef struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipeline DECLSPEC_ALIGN(8) initialPipeline;
-    uint32_t maxPipelineCount;
-} VkIndirectExecutionSetPipelineInfoEXT32;
+    VkBool32 nestedCommandBuffer;
+    VkBool32 nestedCommandBufferRendering;
+    VkBool32 nestedCommandBufferSimultaneousUse;
+} VkPhysicalDeviceNestedCommandBufferFeaturesEXT32;

-typedef struct VkIndirectExecutionSetShaderLayoutInfoEXT32
+typedef struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t setLayoutCount;
-    PTR32 pSetLayouts;
-} VkIndirectExecutionSetShaderLayoutInfoEXT32;
+    uint32_t maxCommandBufferNestingLevel;
+} VkPhysicalDeviceNestedCommandBufferPropertiesEXT32;

-typedef struct VkIndirectExecutionSetShaderInfoEXT32
+typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t shaderCount;
-    PTR32 pInitialShaders;
-    PTR32 pSetLayoutInfos;
-    uint32_t maxShaderCount;
-    uint32_t pushConstantRangeCount;
-    PTR32 pPushConstantRanges;
-} VkIndirectExecutionSetShaderInfoEXT32;
+    VkBool32 nonSeamlessCubeMap;
+} VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32;

-typedef union VkIndirectExecutionSetInfoEXT32
+typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT32
 {
-    PTR32 pPipelineInfo;
-    PTR32 pShaderInfo;
-} VkIndirectExecutionSetInfoEXT32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 micromap;
+    VkBool32 micromapCaptureReplay;
+    VkBool32 micromapHostCommands;
+} VkPhysicalDeviceOpacityMicromapFeaturesEXT32;

-typedef struct VkIndirectExecutionSetCreateInfoEXT32
+typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkIndirectExecutionSetInfoTypeEXT type;
-    VkIndirectExecutionSetInfoEXT32 info;
-} VkIndirectExecutionSetCreateInfoEXT32;
+    uint32_t maxOpacity2StateSubdivisionLevel;
+    uint32_t maxOpacity4StateSubdivisionLevel;
+} VkPhysicalDeviceOpacityMicromapPropertiesEXT32;

-typedef struct VkLayerSettingEXT32
+typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV32
 {
-    PTR32 pLayerName;
-    PTR32 pSettingName;
-    VkLayerSettingTypeEXT type;
-    uint32_t valueCount;
-    PTR32 pValues;
-} VkLayerSettingEXT32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 opticalFlow;
+} VkPhysicalDeviceOpticalFlowFeaturesNV32;

-typedef struct VkApplicationInfo32
+typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pApplicationName;
-    uint32_t applicationVersion;
-    PTR32 pEngineName;
-    uint32_t engineVersion;
-    uint32_t apiVersion;
-} VkApplicationInfo32;
+    VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes;
+    VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes;
+    VkBool32 hintSupported;
+    VkBool32 costSupported;
+    VkBool32 bidirectionalFlowSupported;
+    VkBool32 globalFlowSupported;
+    uint32_t minWidth;
+    uint32_t minHeight;
+    uint32_t maxWidth;
+    uint32_t maxHeight;
+    uint32_t maxNumRegionsOfInterest;
+} VkPhysicalDeviceOpticalFlowPropertiesNV32;

-typedef struct VkValidationFlagsEXT32
+typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t disabledValidationCheckCount;
-    PTR32 pDisabledValidationChecks;
-} VkValidationFlagsEXT32;
+    uint32_t pciDomain;
+    uint32_t pciBus;
+    uint32_t pciDevice;
+    uint32_t pciFunction;
+} VkPhysicalDevicePCIBusInfoPropertiesEXT32;

-typedef struct VkValidationFeaturesEXT32
+typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t enabledValidationFeatureCount;
-    PTR32 pEnabledValidationFeatures;
-    uint32_t disabledValidationFeatureCount;
-    PTR32 pDisabledValidationFeatures;
-} VkValidationFeaturesEXT32;
+    VkBool32 pageableDeviceLocalMemory;
+} VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32;

-typedef struct VkLayerSettingsCreateInfoEXT32
+typedef struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t settingCount;
-    PTR32 pSettings;
-} VkLayerSettingsCreateInfoEXT32;
+    VkBool32 partitionedAccelerationStructure;
+} VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32;

-typedef struct VkInstanceCreateInfo32
+typedef struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkInstanceCreateFlags flags;
-    PTR32 pApplicationInfo;
-    uint32_t enabledLayerCount;
-    PTR32 ppEnabledLayerNames;
-    uint32_t enabledExtensionCount;
-    PTR32 ppEnabledExtensionNames;
-} VkInstanceCreateInfo32;
+    uint32_t maxPartitionCount;
+} VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV32;

-typedef struct VkMicromapCreateInfoEXT32
+typedef struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkMicromapCreateFlagsEXT createFlags;
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-    VkDeviceSize DECLSPEC_ALIGN(8) offset;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-    VkMicromapTypeEXT type;
-    VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
-} VkMicromapCreateInfoEXT32;
+    VkBool32 perStageDescriptorSet;
+    VkBool32 dynamicPipelineLayout;
+} VkPhysicalDevicePerStageDescriptorSetFeaturesNV32;

-typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV32
+typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t id;
-    uint32_t size;
-    PTR32 pPrivateData;
-} VkOpticalFlowSessionCreatePrivateDataInfoNV32;
+    VkBool32 performanceCounterQueryPools;
+    VkBool32 performanceCounterMultipleQueryPools;
+} VkPhysicalDevicePerformanceQueryFeaturesKHR32;

-typedef struct VkOpticalFlowSessionCreateInfoNV32
+typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t width;
-    uint32_t height;
-    VkFormat imageFormat;
-    VkFormat flowVectorFormat;
-    VkFormat costFormat;
-    VkOpticalFlowGridSizeFlagsNV outputGridSize;
-    VkOpticalFlowGridSizeFlagsNV hintGridSize;
-    VkOpticalFlowPerformanceLevelNV performanceLevel;
-    VkOpticalFlowSessionCreateFlagsNV flags;
-} VkOpticalFlowSessionCreateInfoNV32;
+    VkBool32 allowCommandBufferQueryCopies;
+} VkPhysicalDevicePerformanceQueryPropertiesKHR32;

-typedef struct VkPipelineBinaryKeyKHR32
+typedef struct VkPhysicalDevicePipelineBinaryFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t keySize;
-    uint8_t key[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR];
-} VkPipelineBinaryKeyKHR32;
+    VkBool32 pipelineBinaries;
+} VkPhysicalDevicePipelineBinaryFeaturesKHR32;

-typedef struct VkPipelineBinaryDataKHR32
+typedef struct VkPhysicalDevicePipelineBinaryPropertiesKHR32
 {
-    PTR32 dataSize;
-    PTR32 pData;
-} VkPipelineBinaryDataKHR32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 pipelineBinaryInternalCache;
+    VkBool32 pipelineBinaryInternalCacheControl;
+    VkBool32 pipelineBinaryPrefersInternalCache;
+    VkBool32 pipelineBinaryPrecompiledInternalCache;
+    VkBool32 pipelineBinaryCompressedData;
+} VkPhysicalDevicePipelineBinaryPropertiesKHR32;

-typedef struct VkPipelineBinaryKeysAndDataKHR32
+typedef struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32
 {
-    uint32_t binaryCount;
-    PTR32 pPipelineBinaryKeys;
-    PTR32 pPipelineBinaryData;
-} VkPipelineBinaryKeysAndDataKHR32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 pipelineCacheIncrementalMode;
+} VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32;

-typedef struct VkPipelineCreateInfoKHR32
+typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-} VkPipelineCreateInfoKHR32;
+    VkBool32 pipelineCreationCacheControl;
+} VkPhysicalDevicePipelineCreationCacheControlFeatures32;
+typedef VkPhysicalDevicePipelineCreationCacheControlFeatures32 VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT32;

-typedef struct VkPipelineBinaryCreateInfoKHR32
+typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pKeysAndDataInfo;
-    VkPipeline DECLSPEC_ALIGN(8) pipeline;
-    PTR32 pPipelineCreateInfo;
-} VkPipelineBinaryCreateInfoKHR32;
+    VkBool32 pipelineExecutableInfo;
+} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32;

-typedef struct VkPipelineBinaryHandlesInfoKHR32
+typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t pipelineBinaryCount;
-    PTR32 pPipelineBinaries;
-} VkPipelineBinaryHandlesInfoKHR32;
+    VkBool32 pipelineLibraryGroupHandles;
+} VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32;

-typedef struct VkPipelineCacheCreateInfo32
+typedef struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineCacheCreateFlags flags;
-    PTR32 initialDataSize;
-    PTR32 pInitialData;
-} VkPipelineCacheCreateInfo32;
+    VkBool32 pipelineOpacityMicromap;
+} VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32;

-typedef struct VkPrivateDataSlotCreateInfo32
+typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPrivateDataSlotCreateFlags flags;
-} VkPrivateDataSlotCreateInfo32;
-typedef VkPrivateDataSlotCreateInfo32 VkPrivateDataSlotCreateInfoEXT32;
+    VkBool32 pipelinePropertiesIdentifier;
+} VkPhysicalDevicePipelinePropertiesFeaturesEXT32;

-typedef struct VkQueryPoolPerformanceCreateInfoKHR32
+typedef struct VkPhysicalDevicePipelineProtectedAccessFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t queueFamilyIndex;
-    uint32_t counterIndexCount;
-    PTR32 pCounterIndices;
-} VkQueryPoolPerformanceCreateInfoKHR32;
+    VkBool32 pipelineProtectedAccess;
+} VkPhysicalDevicePipelineProtectedAccessFeatures32;
+typedef VkPhysicalDevicePipelineProtectedAccessFeatures32 VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32;

-typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL32
+typedef struct VkPhysicalDevicePipelineRobustnessFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkQueryPoolSamplingModeINTEL performanceCountersSampling;
-} VkQueryPoolPerformanceQueryCreateInfoINTEL32;
-typedef VkQueryPoolPerformanceQueryCreateInfoINTEL32 VkQueryPoolCreateInfoINTEL32;
+    VkBool32 pipelineRobustness;
+} VkPhysicalDevicePipelineRobustnessFeatures32;
+typedef VkPhysicalDevicePipelineRobustnessFeatures32 VkPhysicalDevicePipelineRobustnessFeaturesEXT32;

-typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32
+typedef struct VkPhysicalDevicePipelineRobustnessProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags;
-} VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32;
+    VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers;
+    VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers;
+    VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs;
+    VkPipelineRobustnessImageBehavior defaultRobustnessImages;
+} VkPhysicalDevicePipelineRobustnessProperties32;
+typedef VkPhysicalDevicePipelineRobustnessProperties32 VkPhysicalDevicePipelineRobustnessPropertiesEXT32;

-typedef struct VkQueryPoolCreateInfo32
+typedef struct VkPhysicalDevicePointClippingProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkQueryPoolCreateFlags flags;
-    VkQueryType queryType;
-    uint32_t queryCount;
-    VkQueryPipelineStatisticFlags pipelineStatistics;
-} VkQueryPoolCreateInfo32;
+    VkPointClippingBehavior pointClippingBehavior;
+} VkPhysicalDevicePointClippingProperties32;
+typedef VkPhysicalDevicePointClippingProperties32 VkPhysicalDevicePointClippingPropertiesKHR32;

-typedef struct VkRayTracingShaderGroupCreateInfoKHR32
+typedef struct VkPhysicalDevicePresentBarrierFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkRayTracingShaderGroupTypeKHR type;
-    uint32_t generalShader;
-    uint32_t closestHitShader;
-    uint32_t anyHitShader;
-    uint32_t intersectionShader;
-    PTR32 pShaderGroupCaptureReplayHandle;
-} VkRayTracingShaderGroupCreateInfoKHR32;
+    VkBool32 presentBarrier;
+} VkPhysicalDevicePresentBarrierFeaturesNV32;

-typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR32
+typedef struct VkPhysicalDevicePresentId2FeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxPipelineRayPayloadSize;
-    uint32_t maxPipelineRayHitAttributeSize;
-} VkRayTracingPipelineInterfaceCreateInfoKHR32;
+    VkBool32 presentId2;
+} VkPhysicalDevicePresentId2FeaturesKHR32;

-typedef struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32
+typedef struct VkPhysicalDevicePresentIdFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 allowClusterAccelerationStructure;
-} VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32;
+    VkBool32 presentId;
+} VkPhysicalDevicePresentIdFeaturesKHR32;

-typedef struct VkRayTracingPipelineCreateInfoKHR32
+typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineCreateFlags flags;
-    uint32_t stageCount;
-    PTR32 pStages;
-    uint32_t groupCount;
-    PTR32 pGroups;
-    uint32_t maxPipelineRayRecursionDepth;
-    PTR32 pLibraryInfo;
-    PTR32 pLibraryInterface;
-    PTR32 pDynamicState;
-    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
-    VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
-    int32_t basePipelineIndex;
-} VkRayTracingPipelineCreateInfoKHR32;
+    VkBool32 presentModeFifoLatestReady;
+} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32;
+typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32;

-typedef struct VkRayTracingShaderGroupCreateInfoNV32
+typedef struct VkPhysicalDevicePresentWait2FeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkRayTracingShaderGroupTypeKHR type;
-    uint32_t generalShader;
-    uint32_t closestHitShader;
-    uint32_t anyHitShader;
-    uint32_t intersectionShader;
-} VkRayTracingShaderGroupCreateInfoNV32;
+    VkBool32 presentWait2;
+} VkPhysicalDevicePresentWait2FeaturesKHR32;

-typedef struct VkRayTracingPipelineCreateInfoNV32
+typedef struct VkPhysicalDevicePresentWaitFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineCreateFlags flags;
-    uint32_t stageCount;
-    PTR32 pStages;
-    uint32_t groupCount;
-    PTR32 pGroups;
-    uint32_t maxRecursionDepth;
-    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
-    VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
-    int32_t basePipelineIndex;
-} VkRayTracingPipelineCreateInfoNV32;
+    VkBool32 presentWait;
+} VkPhysicalDevicePresentWaitFeaturesKHR32;

-typedef struct VkSubpassDescription32
+typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32
 {
-    VkSubpassDescriptionFlags flags;
-    VkPipelineBindPoint pipelineBindPoint;
-    uint32_t inputAttachmentCount;
-    PTR32 pInputAttachments;
-    uint32_t colorAttachmentCount;
-    PTR32 pColorAttachments;
-    PTR32 pResolveAttachments;
-    PTR32 pDepthStencilAttachment;
-    uint32_t preserveAttachmentCount;
-    PTR32 pPreserveAttachments;
-} VkSubpassDescription32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 primitiveTopologyListRestart;
+    VkBool32 primitiveTopologyPatchListRestart;
+} VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32;

-typedef struct VkRenderPassMultiviewCreateInfo32
+typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t subpassCount;
-    PTR32 pViewMasks;
-    uint32_t dependencyCount;
-    PTR32 pViewOffsets;
-    uint32_t correlationMaskCount;
-    PTR32 pCorrelationMasks;
-} VkRenderPassMultiviewCreateInfo32;
-typedef VkRenderPassMultiviewCreateInfo32 VkRenderPassMultiviewCreateInfoKHR32;
+    VkBool32 primitivesGeneratedQuery;
+    VkBool32 primitivesGeneratedQueryWithRasterizerDiscard;
+    VkBool32 primitivesGeneratedQueryWithNonZeroStreams;
+} VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32;

-typedef struct VkRenderPassInputAttachmentAspectCreateInfo32
+typedef struct VkPhysicalDevicePrivateDataFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t aspectReferenceCount;
-    PTR32 pAspectReferences;
-} VkRenderPassInputAttachmentAspectCreateInfo32;
-typedef VkRenderPassInputAttachmentAspectCreateInfo32 VkRenderPassInputAttachmentAspectCreateInfoKHR32;
+    VkBool32 privateData;
+} VkPhysicalDevicePrivateDataFeatures32;
+typedef VkPhysicalDevicePrivateDataFeatures32 VkPhysicalDevicePrivateDataFeaturesEXT32;

-typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT32
+typedef struct VkPhysicalDeviceProtectedMemoryFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAttachmentReference fragmentDensityMapAttachment;
-} VkRenderPassFragmentDensityMapCreateInfoEXT32;
+    VkBool32 protectedMemory;
+} VkPhysicalDeviceProtectedMemoryFeatures32;

-typedef struct VkRenderPassCreateInfo32
+typedef struct VkPhysicalDeviceProtectedMemoryProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkRenderPassCreateFlags flags;
-    uint32_t attachmentCount;
-    PTR32 pAttachments;
-    uint32_t subpassCount;
-    PTR32 pSubpasses;
-    uint32_t dependencyCount;
-    PTR32 pDependencies;
-} VkRenderPassCreateInfo32;
+    VkBool32 protectedNoFault;
+} VkPhysicalDeviceProtectedMemoryProperties32;

-typedef struct VkAttachmentDescriptionStencilLayout32
+typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageLayout stencilInitialLayout;
-    VkImageLayout stencilFinalLayout;
-} VkAttachmentDescriptionStencilLayout32;
-typedef VkAttachmentDescriptionStencilLayout32 VkAttachmentDescriptionStencilLayoutKHR32;
+    VkBool32 provokingVertexLast;
+    VkBool32 transformFeedbackPreservesProvokingVertex;
+} VkPhysicalDeviceProvokingVertexFeaturesEXT32;

-typedef struct VkAttachmentDescription232
+typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAttachmentDescriptionFlags flags;
-    VkFormat format;
-    VkSampleCountFlagBits samples;
-    VkAttachmentLoadOp loadOp;
-    VkAttachmentStoreOp storeOp;
-    VkAttachmentLoadOp stencilLoadOp;
-    VkAttachmentStoreOp stencilStoreOp;
-    VkImageLayout initialLayout;
-    VkImageLayout finalLayout;
-} VkAttachmentDescription232;
-typedef VkAttachmentDescription232 VkAttachmentDescription2KHR32;
+    VkBool32 provokingVertexModePerPipeline;
+    VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex;
+} VkPhysicalDeviceProvokingVertexPropertiesEXT32;

-typedef struct VkAttachmentReferenceStencilLayout32
+typedef struct VkPhysicalDevicePushDescriptorProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageLayout stencilLayout;
-} VkAttachmentReferenceStencilLayout32;
-typedef VkAttachmentReferenceStencilLayout32 VkAttachmentReferenceStencilLayoutKHR32;
+    uint32_t maxPushDescriptors;
+} VkPhysicalDevicePushDescriptorProperties32;
+typedef VkPhysicalDevicePushDescriptorProperties32 VkPhysicalDevicePushDescriptorPropertiesKHR32;

-typedef struct VkAttachmentReference232
+typedef struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t attachment;
-    VkImageLayout layout;
-    VkImageAspectFlags aspectMask;
-} VkAttachmentReference232;
-typedef VkAttachmentReference232 VkAttachmentReference2KHR32;
+    uint32_t queueFamilyIndex;
+    VkPhysicalDeviceDataGraphProcessingEngineTypeARM engineType;
+} VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32;

-typedef struct VkSubpassDescriptionDepthStencilResolve32
+typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkResolveModeFlagBits depthResolveMode;
-    VkResolveModeFlagBits stencilResolveMode;
-    PTR32 pDepthStencilResolveAttachment;
-} VkSubpassDescriptionDepthStencilResolve32;
-typedef VkSubpassDescriptionDepthStencilResolve32 VkSubpassDescriptionDepthStencilResolveKHR32;
+    VkBool32 formatRgba10x6WithoutYCbCrSampler;
+} VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32;

-typedef struct VkFragmentShadingRateAttachmentInfoKHR32
+typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pFragmentShadingRateAttachment;
-    VkExtent2D shadingRateAttachmentTexelSize;
-} VkFragmentShadingRateAttachmentInfoKHR32;
+    VkBool32 rasterizationOrderColorAttachmentAccess;
+    VkBool32 rasterizationOrderDepthAttachmentAccess;
+    VkBool32 rasterizationOrderStencilAttachmentAccess;
+} VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32;
+typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM32;

-typedef struct VkRenderPassCreationControlEXT32
+typedef struct VkPhysicalDeviceRawAccessChainsFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 disallowMerging;
-} VkRenderPassCreationControlEXT32;
+    VkBool32 shaderRawAccessChains;
+} VkPhysicalDeviceRawAccessChainsFeaturesNV32;

-typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT32
+typedef struct VkPhysicalDeviceRayQueryFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pSubpassFeedback;
-} VkRenderPassSubpassFeedbackCreateInfoEXT32;
+    VkBool32 rayQuery;
+} VkPhysicalDeviceRayQueryFeaturesKHR32;

-typedef struct VkSubpassDescription232
+typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSubpassDescriptionFlags flags;
-    VkPipelineBindPoint pipelineBindPoint;
-    uint32_t viewMask;
-    uint32_t inputAttachmentCount;
-    PTR32 pInputAttachments;
-    uint32_t colorAttachmentCount;
-    PTR32 pColorAttachments;
-    PTR32 pResolveAttachments;
-    PTR32 pDepthStencilAttachment;
-    uint32_t preserveAttachmentCount;
-    PTR32 pPreserveAttachments;
-} VkSubpassDescription232;
-typedef VkSubpassDescription232 VkSubpassDescription2KHR32;
+    VkBool32 rayTracingInvocationReorder;
+} VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32;

-typedef struct VkSubpassDependency232
+typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t srcSubpass;
-    uint32_t dstSubpass;
-    VkPipelineStageFlags srcStageMask;
-    VkPipelineStageFlags dstStageMask;
-    VkAccessFlags srcAccessMask;
-    VkAccessFlags dstAccessMask;
-    VkDependencyFlags dependencyFlags;
-    int32_t viewOffset;
-} VkSubpassDependency232;
-typedef VkSubpassDependency232 VkSubpassDependency2KHR32;
+    VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint;
+} VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32;

-typedef struct VkRenderPassCreationFeedbackCreateInfoEXT32
+typedef struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pRenderPassFeedback;
-} VkRenderPassCreationFeedbackCreateInfoEXT32;
+    VkBool32 spheres;
+    VkBool32 linearSweptSpheres;
+} VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV32;

-typedef struct VkRenderPassCreateInfo232
+typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkRenderPassCreateFlags flags;
-    uint32_t attachmentCount;
-    PTR32 pAttachments;
-    uint32_t subpassCount;
-    PTR32 pSubpasses;
-    uint32_t dependencyCount;
-    PTR32 pDependencies;
-    uint32_t correlatedViewMaskCount;
-    PTR32 pCorrelatedViewMasks;
-} VkRenderPassCreateInfo232;
-typedef VkRenderPassCreateInfo232 VkRenderPassCreateInfo2KHR32;
+    VkBool32 rayTracingMaintenance1;
+    VkBool32 rayTracingPipelineTraceRaysIndirect2;
+} VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32;

-typedef struct VkSamplerReductionModeCreateInfo32
+typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSamplerReductionMode reductionMode;
-} VkSamplerReductionModeCreateInfo32;
-typedef VkSamplerReductionModeCreateInfo32 VkSamplerReductionModeCreateInfoEXT32;
+    VkBool32 rayTracingMotionBlur;
+    VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect;
+} VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32;

-typedef struct VkSamplerCustomBorderColorCreateInfoEXT32
+typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkClearColorValue customBorderColor;
-    VkFormat format;
-} VkSamplerCustomBorderColorCreateInfoEXT32;
+    VkBool32 rayTracingPipeline;
+    VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay;
+    VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
+    VkBool32 rayTracingPipelineTraceRaysIndirect;
+    VkBool32 rayTraversalPrimitiveCulling;
+} VkPhysicalDeviceRayTracingPipelineFeaturesKHR32;

-typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT32
+typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkComponentMapping components;
-    VkBool32 srgb;
-} VkSamplerBorderColorComponentMappingCreateInfoEXT32;
+    uint32_t shaderGroupHandleSize;
+    uint32_t maxRayRecursionDepth;
+    uint32_t maxShaderGroupStride;
+    uint32_t shaderGroupBaseAlignment;
+    uint32_t shaderGroupHandleCaptureReplaySize;
+    uint32_t maxRayDispatchInvocationCount;
+    uint32_t shaderGroupHandleAlignment;
+    uint32_t maxRayHitAttributeSize;
+} VkPhysicalDeviceRayTracingPipelinePropertiesKHR32;

-typedef struct VkSamplerCubicWeightsCreateInfoQCOM32
+typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkCubicFilterWeightsQCOM cubicWeights;
-} VkSamplerCubicWeightsCreateInfoQCOM32;
+    VkBool32 rayTracingPositionFetch;
+} VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32;

-typedef struct VkSamplerBlockMatchWindowCreateInfoQCOM32
+typedef struct VkPhysicalDeviceRayTracingPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExtent2D windowExtent;
-    VkBlockMatchWindowCompareModeQCOM windowCompareMode;
-} VkSamplerBlockMatchWindowCreateInfoQCOM32;
+    uint32_t shaderGroupHandleSize;
+    uint32_t maxRecursionDepth;
+    uint32_t maxShaderGroupStride;
+    uint32_t shaderGroupBaseAlignment;
+    uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
+    uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
+    uint64_t DECLSPEC_ALIGN(8) maxTriangleCount;
+    uint32_t maxDescriptorSetAccelerationStructures;
+} VkPhysicalDeviceRayTracingPropertiesNV32;

-typedef struct VkSamplerCreateInfo32
+typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSamplerCreateFlags flags;
-    VkFilter magFilter;
-    VkFilter minFilter;
-    VkSamplerMipmapMode mipmapMode;
-    VkSamplerAddressMode addressModeU;
-    VkSamplerAddressMode addressModeV;
-    VkSamplerAddressMode addressModeW;
-    float mipLodBias;
-    VkBool32 anisotropyEnable;
-    float maxAnisotropy;
-    VkBool32 compareEnable;
-    VkCompareOp compareOp;
-    float minLod;
-    float maxLod;
-    VkBorderColor borderColor;
-    VkBool32 unnormalizedCoordinates;
-} VkSamplerCreateInfo32;
+    VkBool32 rayTracingValidation;
+} VkPhysicalDeviceRayTracingValidationFeaturesNV32;

-typedef struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM32
+typedef struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 enableYDegamma;
-    VkBool32 enableCbCrDegamma;
-} VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM32;
+    VkBool32 relaxedLineRasterization;
+} VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32;

-typedef struct VkSamplerYcbcrConversionCreateInfo32
+typedef struct VkPhysicalDeviceRenderPassStripedFeaturesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkFormat format;
-    VkSamplerYcbcrModelConversion ycbcrModel;
-    VkSamplerYcbcrRange ycbcrRange;
-    VkComponentMapping components;
-    VkChromaLocation xChromaOffset;
-    VkChromaLocation yChromaOffset;
-    VkFilter chromaFilter;
-    VkBool32 forceExplicitReconstruction;
-} VkSamplerYcbcrConversionCreateInfo32;
-typedef VkSamplerYcbcrConversionCreateInfo32 VkSamplerYcbcrConversionCreateInfoKHR32;
+    VkBool32 renderPassStriped;
+} VkPhysicalDeviceRenderPassStripedFeaturesARM32;

-typedef struct VkExportSemaphoreCreateInfo32
+typedef struct VkPhysicalDeviceRenderPassStripedPropertiesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalSemaphoreHandleTypeFlags handleTypes;
-} VkExportSemaphoreCreateInfo32;
-typedef VkExportSemaphoreCreateInfo32 VkExportSemaphoreCreateInfoKHR32;
+    VkExtent2D renderPassStripeGranularity;
+    uint32_t maxRenderPassStripes;
+} VkPhysicalDeviceRenderPassStripedPropertiesARM32;

-typedef struct VkSemaphoreTypeCreateInfo32
+typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSemaphoreType semaphoreType;
-    uint64_t DECLSPEC_ALIGN(8) initialValue;
-} VkSemaphoreTypeCreateInfo32;
-typedef VkSemaphoreTypeCreateInfo32 VkSemaphoreTypeCreateInfoKHR32;
+    VkBool32 representativeFragmentTest;
+} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32;

-typedef struct VkQueryLowLatencySupportNV32
+typedef struct VkPhysicalDeviceRobustness2FeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pQueriedLowLatencyData;
-} VkQueryLowLatencySupportNV32;
+    VkBool32 robustBufferAccess2;
+    VkBool32 robustImageAccess2;
+    VkBool32 nullDescriptor;
+} VkPhysicalDeviceRobustness2FeaturesKHR32;
+typedef VkPhysicalDeviceRobustness2FeaturesKHR32 VkPhysicalDeviceRobustness2FeaturesEXT32;

-typedef struct VkSemaphoreCreateInfo32
+typedef struct VkPhysicalDeviceRobustness2PropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSemaphoreCreateFlags flags;
-} VkSemaphoreCreateInfo32;
+    VkDeviceSize DECLSPEC_ALIGN(8) robustStorageBufferAccessSizeAlignment;
+    VkDeviceSize DECLSPEC_ALIGN(8) robustUniformBufferAccessSizeAlignment;
+} VkPhysicalDeviceRobustness2PropertiesKHR32;
+typedef VkPhysicalDeviceRobustness2PropertiesKHR32 VkPhysicalDeviceRobustness2PropertiesEXT32;

-typedef struct VkShaderCreateInfoEXT32
+typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderCreateFlagsEXT flags;
-    VkShaderStageFlagBits stage;
-    VkShaderStageFlags nextStage;
-    VkShaderCodeTypeEXT codeType;
-    PTR32 codeSize;
-    PTR32 pCode;
-    PTR32 pName;
-    uint32_t setLayoutCount;
-    PTR32 pSetLayouts;
-    uint32_t pushConstantRangeCount;
-    PTR32 pPushConstantRanges;
-    PTR32 pSpecializationInfo;
-} VkShaderCreateInfoEXT32;
+    VkSampleCountFlags sampleLocationSampleCounts;
+    VkExtent2D maxSampleLocationGridSize;
+    float sampleLocationCoordinateRange[2];
+    uint32_t sampleLocationSubPixelBits;
+    VkBool32 variableSampleLocations;
+} VkPhysicalDeviceSampleLocationsPropertiesEXT32;

-typedef struct VkDeviceGroupSwapchainCreateInfoKHR32
+typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceGroupPresentModeFlagsKHR modes;
-} VkDeviceGroupSwapchainCreateInfoKHR32;
+    VkBool32 filterMinmaxSingleComponentFormats;
+    VkBool32 filterMinmaxImageComponentMapping;
+} VkPhysicalDeviceSamplerFilterMinmaxProperties32;
+typedef VkPhysicalDeviceSamplerFilterMinmaxProperties32 VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT32;

-typedef struct VkSwapchainPresentBarrierCreateInfoNV32
+typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 presentBarrierEnable;
-} VkSwapchainPresentBarrierCreateInfoNV32;
+    VkBool32 samplerYcbcrConversion;
+} VkPhysicalDeviceSamplerYcbcrConversionFeatures32;
+typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures32 VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR32;

-typedef struct VkSwapchainPresentModesCreateInfoKHR32
+typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t presentModeCount;
-    PTR32 pPresentModes;
-} VkSwapchainPresentModesCreateInfoKHR32;
-typedef VkSwapchainPresentModesCreateInfoKHR32 VkSwapchainPresentModesCreateInfoEXT32;
+    VkBool32 scalarBlockLayout;
+} VkPhysicalDeviceScalarBlockLayoutFeatures32;
+typedef VkPhysicalDeviceScalarBlockLayoutFeatures32 VkPhysicalDeviceScalarBlockLayoutFeaturesEXT32;

-typedef struct VkSwapchainPresentScalingCreateInfoKHR32
+typedef struct VkPhysicalDeviceSchedulingControlsFeaturesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPresentScalingFlagsKHR scalingBehavior;
-    VkPresentGravityFlagsKHR presentGravityX;
-    VkPresentGravityFlagsKHR presentGravityY;
-} VkSwapchainPresentScalingCreateInfoKHR32;
-typedef VkSwapchainPresentScalingCreateInfoKHR32 VkSwapchainPresentScalingCreateInfoEXT32;
+    VkBool32 schedulingControls;
+} VkPhysicalDeviceSchedulingControlsFeaturesARM32;

-typedef struct VkSwapchainLatencyCreateInfoNV32
+typedef struct VkPhysicalDeviceSchedulingControlsPropertiesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 latencyModeEnable;
-} VkSwapchainLatencyCreateInfoNV32;
+    VkPhysicalDeviceSchedulingControlsFlagsARM DECLSPEC_ALIGN(8) schedulingControlsFlags;
+} VkPhysicalDeviceSchedulingControlsPropertiesARM32;

-typedef struct VkSwapchainCreateInfoKHR32
+typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSwapchainCreateFlagsKHR flags;
-    VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
-    uint32_t minImageCount;
-    VkFormat imageFormat;
-    VkColorSpaceKHR imageColorSpace;
-    VkExtent2D imageExtent;
-    uint32_t imageArrayLayers;
-    VkImageUsageFlags imageUsage;
-    VkSharingMode imageSharingMode;
-    uint32_t queueFamilyIndexCount;
-    PTR32 pQueueFamilyIndices;
-    VkSurfaceTransformFlagBitsKHR preTransform;
-    VkCompositeAlphaFlagBitsKHR compositeAlpha;
-    VkPresentModeKHR presentMode;
-    VkBool32 clipped;
-    VkSwapchainKHR DECLSPEC_ALIGN(8) oldSwapchain;
-} VkSwapchainCreateInfoKHR32;
+    VkBool32 separateDepthStencilLayouts;
+} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32;
+typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR32;

-typedef struct VkExternalMemoryTensorCreateInfoARM32
+typedef struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalMemoryHandleTypeFlags handleTypes;
-} VkExternalMemoryTensorCreateInfoARM32;
+    VkBool32 shaderFloat16VectorAtomics;
+} VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32;

-typedef struct VkTensorCreateInfoARM32
+typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkTensorCreateFlagsARM DECLSPEC_ALIGN(8) flags;
-    PTR32 pDescription;
-    VkSharingMode sharingMode;
-    uint32_t queueFamilyIndexCount;
-    PTR32 pQueueFamilyIndices;
-} VkTensorCreateInfoARM32;
+    VkBool32 shaderBufferFloat16Atomics;
+    VkBool32 shaderBufferFloat16AtomicAdd;
+    VkBool32 shaderBufferFloat16AtomicMinMax;
+    VkBool32 shaderBufferFloat32AtomicMinMax;
+    VkBool32 shaderBufferFloat64AtomicMinMax;
+    VkBool32 shaderSharedFloat16Atomics;
+    VkBool32 shaderSharedFloat16AtomicAdd;
+    VkBool32 shaderSharedFloat16AtomicMinMax;
+    VkBool32 shaderSharedFloat32AtomicMinMax;
+    VkBool32 shaderSharedFloat64AtomicMinMax;
+    VkBool32 shaderImageFloat32AtomicMinMax;
+    VkBool32 sparseImageFloat32AtomicMinMax;
+} VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32;

-typedef struct VkTensorViewCreateInfoARM32
+typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkTensorViewCreateFlagsARM DECLSPEC_ALIGN(8) flags;
-    VkTensorARM DECLSPEC_ALIGN(8) tensor;
-    VkFormat format;
-} VkTensorViewCreateInfoARM32;
+    VkBool32 shaderBufferFloat32Atomics;
+    VkBool32 shaderBufferFloat32AtomicAdd;
+    VkBool32 shaderBufferFloat64Atomics;
+    VkBool32 shaderBufferFloat64AtomicAdd;
+    VkBool32 shaderSharedFloat32Atomics;
+    VkBool32 shaderSharedFloat32AtomicAdd;
+    VkBool32 shaderSharedFloat64Atomics;
+    VkBool32 shaderSharedFloat64AtomicAdd;
+    VkBool32 shaderImageFloat32Atomics;
+    VkBool32 shaderImageFloat32AtomicAdd;
+    VkBool32 sparseImageFloat32Atomics;
+    VkBool32 sparseImageFloat32AtomicAdd;
+} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32;

-typedef struct VkValidationCacheCreateInfoEXT32
+typedef struct VkPhysicalDeviceShaderAtomicInt64Features32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkValidationCacheCreateFlagsEXT flags;
-    PTR32 initialDataSize;
-    PTR32 pInitialData;
-} VkValidationCacheCreateInfoEXT32;
+    VkBool32 shaderBufferInt64Atomics;
+    VkBool32 shaderSharedInt64Atomics;
+} VkPhysicalDeviceShaderAtomicInt64Features32;
+typedef VkPhysicalDeviceShaderAtomicInt64Features32 VkPhysicalDeviceShaderAtomicInt64FeaturesKHR32;

-typedef struct VkVideoEncodeH264SessionCreateInfoKHR32
+typedef struct VkPhysicalDeviceShaderBfloat16FeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 useMaxLevelIdc;
-    StdVideoH264LevelIdc maxLevelIdc;
-} VkVideoEncodeH264SessionCreateInfoKHR32;
+    VkBool32 shaderBFloat16Type;
+    VkBool32 shaderBFloat16DotProduct;
+    VkBool32 shaderBFloat16CooperativeMatrix;
+} VkPhysicalDeviceShaderBfloat16FeaturesKHR32;

-typedef struct VkVideoEncodeAV1SessionCreateInfoKHR32
+typedef struct VkPhysicalDeviceShaderClockFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 useMaxLevel;
-    StdVideoAV1Level maxLevel;
-} VkVideoEncodeAV1SessionCreateInfoKHR32;
+    VkBool32 shaderSubgroupClock;
+    VkBool32 shaderDeviceClock;
+} VkPhysicalDeviceShaderClockFeaturesKHR32;

-typedef struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR32
+typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode;
-} VkVideoEncodeSessionIntraRefreshCreateInfoKHR32;
+    VkBool32 shaderCoreBuiltins;
+} VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32;

-typedef struct VkVideoSessionCreateInfoKHR32
+typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t queueFamilyIndex;
-    VkVideoSessionCreateFlagsKHR flags;
-    PTR32 pVideoProfile;
-    VkFormat pictureFormat;
-    VkExtent2D maxCodedExtent;
-    VkFormat referencePictureFormat;
-    uint32_t maxDpbSlots;
-    uint32_t maxActiveReferencePictures;
-    PTR32 pStdHeaderVersion;
-} VkVideoSessionCreateInfoKHR32;
+    uint64_t DECLSPEC_ALIGN(8) shaderCoreMask;
+    uint32_t shaderCoreCount;
+    uint32_t shaderWarpsPerCore;
+} VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32;

-typedef struct StdVideoH264SequenceParameterSetVui32
+typedef struct VkPhysicalDeviceShaderCoreProperties2AMD32
 {
-    StdVideoH264SpsVuiFlags flags;
-    StdVideoH264AspectRatioIdc aspect_ratio_idc;
-    uint16_t sar_width;
-    uint16_t sar_height;
-    uint8_t video_format;
-    uint8_t colour_primaries;
-    uint8_t transfer_characteristics;
-    uint8_t matrix_coefficients;
-    uint32_t num_units_in_tick;
-    uint32_t time_scale;
-    uint8_t max_num_reorder_frames;
-    uint8_t max_dec_frame_buffering;
-    uint8_t chroma_sample_loc_type_top_field;
-    uint8_t chroma_sample_loc_type_bottom_field;
-    uint32_t reserved1;
-    PTR32 pHrdParameters;
-} StdVideoH264SequenceParameterSetVui32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
+    uint32_t activeComputeUnitCount;
+} VkPhysicalDeviceShaderCoreProperties2AMD32;

-typedef struct StdVideoH264SequenceParameterSet32
+typedef struct VkPhysicalDeviceShaderCorePropertiesAMD32
 {
-    StdVideoH264SpsFlags flags;
-    StdVideoH264ProfileIdc profile_idc;
-    StdVideoH264LevelIdc level_idc;
-    StdVideoH264ChromaFormatIdc chroma_format_idc;
-    uint8_t seq_parameter_set_id;
-    uint8_t bit_depth_luma_minus8;
-    uint8_t bit_depth_chroma_minus8;
-    uint8_t log2_max_frame_num_minus4;
-    StdVideoH264PocType pic_order_cnt_type;
-    int32_t offset_for_non_ref_pic;
-    int32_t offset_for_top_to_bottom_field;
-    uint8_t log2_max_pic_order_cnt_lsb_minus4;
-    uint8_t num_ref_frames_in_pic_order_cnt_cycle;
-    uint8_t max_num_ref_frames;
-    uint8_t reserved1;
-    uint32_t pic_width_in_mbs_minus1;
-    uint32_t pic_height_in_map_units_minus1;
-    uint32_t frame_crop_left_offset;
-    uint32_t frame_crop_right_offset;
-    uint32_t frame_crop_top_offset;
-    uint32_t frame_crop_bottom_offset;
-    uint32_t reserved2;
-    PTR32 pOffsetForRefFrame;
-    PTR32 pScalingLists;
-    PTR32 pSequenceParameterSetVui;
-} StdVideoH264SequenceParameterSet32;
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t shaderEngineCount;
+    uint32_t shaderArraysPerEngineCount;
+    uint32_t computeUnitsPerShaderArray;
+    uint32_t simdPerComputeUnit;
+    uint32_t wavefrontsPerSimd;
+    uint32_t wavefrontSize;
+    uint32_t sgprsPerSimd;
+    uint32_t minSgprAllocation;
+    uint32_t maxSgprAllocation;
+    uint32_t sgprAllocationGranularity;
+    uint32_t vgprsPerSimd;
+    uint32_t minVgprAllocation;
+    uint32_t maxVgprAllocation;
+    uint32_t vgprAllocationGranularity;
+} VkPhysicalDeviceShaderCorePropertiesAMD32;

-typedef struct StdVideoH264PictureParameterSet32
+typedef struct VkPhysicalDeviceShaderCorePropertiesARM32
 {
-    StdVideoH264PpsFlags flags;
-    uint8_t seq_parameter_set_id;
-    uint8_t pic_parameter_set_id;
-    uint8_t num_ref_idx_l0_default_active_minus1;
-    uint8_t num_ref_idx_l1_default_active_minus1;
-    StdVideoH264WeightedBipredIdc weighted_bipred_idc;
-    int8_t pic_init_qp_minus26;
-    int8_t pic_init_qs_minus26;
-    int8_t chroma_qp_index_offset;
-    int8_t second_chroma_qp_index_offset;
-    PTR32 pScalingLists;
-} StdVideoH264PictureParameterSet32;
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t pixelRate;
+    uint32_t texelRate;
+    uint32_t fmaRate;
+} VkPhysicalDeviceShaderCorePropertiesARM32;

-typedef struct VkVideoDecodeH264SessionParametersAddInfoKHR32
+typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t stdSPSCount;
-    PTR32 pStdSPSs;
-    uint32_t stdPPSCount;
-    PTR32 pStdPPSs;
-} VkVideoDecodeH264SessionParametersAddInfoKHR32;
+    VkBool32 shaderDemoteToHelperInvocation;
+} VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32;
+typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT32;

-typedef struct StdVideoAV1SequenceHeader32
+typedef struct VkPhysicalDeviceShaderDrawParametersFeatures32
 {
-    StdVideoAV1SequenceHeaderFlags flags;
-    StdVideoAV1Profile seq_profile;
-    uint8_t frame_width_bits_minus_1;
-    uint8_t frame_height_bits_minus_1;
-    uint16_t max_frame_width_minus_1;
-    uint16_t max_frame_height_minus_1;
-    uint8_t delta_frame_id_length_minus_2;
-    uint8_t additional_frame_id_length_minus_1;
-    uint8_t order_hint_bits_minus_1;
-    uint8_t seq_force_integer_mv;
-    uint8_t seq_force_screen_content_tools;
-    uint8_t reserved1[5];
-    PTR32 pColorConfig;
-    PTR32 pTimingInfo;
-} StdVideoAV1SequenceHeader32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 shaderDrawParameters;
+} VkPhysicalDeviceShaderDrawParametersFeatures32;
+typedef VkPhysicalDeviceShaderDrawParametersFeatures32 VkPhysicalDeviceShaderDrawParameterFeatures32;

-typedef struct VkVideoEncodeH264SessionParametersAddInfoKHR32
+typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t stdSPSCount;
-    PTR32 pStdSPSs;
-    uint32_t stdPPSCount;
-    PTR32 pStdPPSs;
-} VkVideoEncodeH264SessionParametersAddInfoKHR32;
+    VkBool32 shaderEarlyAndLateFragmentTests;
+} VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32;

-typedef struct VkVideoDecodeH264SessionParametersCreateInfoKHR32
+typedef struct VkPhysicalDeviceShaderExpectAssumeFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxStdSPSCount;
-    uint32_t maxStdPPSCount;
-    PTR32 pParametersAddInfo;
-} VkVideoDecodeH264SessionParametersCreateInfoKHR32;
+    VkBool32 shaderExpectAssume;
+} VkPhysicalDeviceShaderExpectAssumeFeatures32;
+typedef VkPhysicalDeviceShaderExpectAssumeFeatures32 VkPhysicalDeviceShaderExpectAssumeFeaturesKHR32;

-typedef struct VkVideoDecodeAV1SessionParametersCreateInfoKHR32
+typedef struct VkPhysicalDeviceShaderFloat16Int8Features32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pStdSequenceHeader;
-} VkVideoDecodeAV1SessionParametersCreateInfoKHR32;
+    VkBool32 shaderFloat16;
+    VkBool32 shaderInt8;
+} VkPhysicalDeviceShaderFloat16Int8Features32;
+typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceShaderFloat16Int8FeaturesKHR32;
+typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceFloat16Int8FeaturesKHR32;

-typedef struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32
+typedef struct VkPhysicalDeviceShaderFloat8FeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExtent2D quantizationMapTexelSize;
-} VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32;
+    VkBool32 shaderFloat8;
+    VkBool32 shaderFloat8CooperativeMatrix;
+} VkPhysicalDeviceShaderFloat8FeaturesEXT32;

-typedef struct VkVideoEncodeH264SessionParametersCreateInfoKHR32
+typedef struct VkPhysicalDeviceShaderFloatControls2Features32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxStdSPSCount;
-    uint32_t maxStdPPSCount;
-    PTR32 pParametersAddInfo;
-} VkVideoEncodeH264SessionParametersCreateInfoKHR32;
+    VkBool32 shaderFloatControls2;
+} VkPhysicalDeviceShaderFloatControls2Features32;
+typedef VkPhysicalDeviceShaderFloatControls2Features32 VkPhysicalDeviceShaderFloatControls2FeaturesKHR32;

-typedef struct VkVideoEncodeAV1SessionParametersCreateInfoKHR32
+typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pStdSequenceHeader;
-    PTR32 pStdDecoderModelInfo;
-    uint32_t stdOperatingPointCount;
-    PTR32 pStdOperatingPoints;
-} VkVideoEncodeAV1SessionParametersCreateInfoKHR32;
+    VkBool32 shaderImageInt64Atomics;
+    VkBool32 sparseImageInt64Atomics;
+} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32;

-typedef struct VkVideoSessionParametersCreateInfoKHR32
+typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoSessionParametersCreateFlagsKHR flags;
-    VkVideoSessionParametersKHR DECLSPEC_ALIGN(8) videoSessionParametersTemplate;
-    VkVideoSessionKHR DECLSPEC_ALIGN(8) videoSession;
-} VkVideoSessionParametersCreateInfoKHR32;
+    VkBool32 imageFootprint;
+} VkPhysicalDeviceShaderImageFootprintFeaturesNV32;

-typedef struct VkWin32SurfaceCreateInfoKHR32
+typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkWin32SurfaceCreateFlagsKHR flags;
-    PTR32 hinstance;
-    PTR32 hwnd;
-} VkWin32SurfaceCreateInfoKHR32;
+    VkBool32 shaderIntegerDotProduct;
+} VkPhysicalDeviceShaderIntegerDotProductFeatures32;
+typedef VkPhysicalDeviceShaderIntegerDotProductFeatures32 VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR32;

-typedef struct VkDebugMarkerObjectNameInfoEXT32
+typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDebugReportObjectTypeEXT objectType;
-    uint64_t DECLSPEC_ALIGN(8) object;
-    PTR32 pObjectName;
-} VkDebugMarkerObjectNameInfoEXT32;
+    VkBool32 integerDotProduct8BitUnsignedAccelerated;
+    VkBool32 integerDotProduct8BitSignedAccelerated;
+    VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+    VkBool32 integerDotProduct16BitUnsignedAccelerated;
+    VkBool32 integerDotProduct16BitSignedAccelerated;
+    VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct32BitUnsignedAccelerated;
+    VkBool32 integerDotProduct32BitSignedAccelerated;
+    VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct64BitUnsignedAccelerated;
+    VkBool32 integerDotProduct64BitSignedAccelerated;
+    VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+} VkPhysicalDeviceShaderIntegerDotProductProperties32;
+typedef VkPhysicalDeviceShaderIntegerDotProductProperties32 VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR32;

-typedef struct VkDebugMarkerObjectTagInfoEXT32
+typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDebugReportObjectTypeEXT objectType;
-    uint64_t DECLSPEC_ALIGN(8) object;
-    uint64_t DECLSPEC_ALIGN(8) tagName;
-    PTR32 tagSize;
-    PTR32 pTag;
-} VkDebugMarkerObjectTagInfoEXT32;
+    VkBool32 shaderIntegerFunctions2;
+} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32;

-typedef struct VkPhysicalDeviceGroupProperties32
+typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t physicalDeviceCount;
-    PTR32 physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
-    VkBool32 subsetAllocation;
-} VkPhysicalDeviceGroupProperties32;
-typedef VkPhysicalDeviceGroupProperties32 VkPhysicalDeviceGroupPropertiesKHR32;
+    VkBool32 shaderMaximalReconvergence;
+} VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32;

-typedef struct VkPerformanceCounterKHR32
+typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPerformanceCounterUnitKHR unit;
-    VkPerformanceCounterScopeKHR scope;
-    VkPerformanceCounterStorageKHR storage;
-    uint8_t uuid[VK_UUID_SIZE];
-} VkPerformanceCounterKHR32;
+    VkBool32 shaderModuleIdentifier;
+} VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32;

-typedef struct VkPerformanceCounterDescriptionKHR32
+typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPerformanceCounterDescriptionFlagsKHR flags;
-    char name[VK_MAX_DESCRIPTION_SIZE];
-    char category[VK_MAX_DESCRIPTION_SIZE];
-    char description[VK_MAX_DESCRIPTION_SIZE];
-} VkPerformanceCounterDescriptionKHR32;
+    uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE];
+} VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32;

-typedef struct VkMappedMemoryRange32
+typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
-    VkDeviceSize DECLSPEC_ALIGN(8) offset;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-} VkMappedMemoryRange32;
+    VkBool32 shaderObject;
+} VkPhysicalDeviceShaderObjectFeaturesEXT32;

-typedef struct VkAccelerationStructureBuildSizesInfoKHR32
+typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) accelerationStructureSize;
-    VkDeviceSize DECLSPEC_ALIGN(8) updateScratchSize;
-    VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
-} VkAccelerationStructureBuildSizesInfoKHR32;
+    uint8_t shaderBinaryUUID[VK_UUID_SIZE];
+    uint32_t shaderBinaryVersion;
+} VkPhysicalDeviceShaderObjectPropertiesEXT32;

-typedef struct VkAccelerationStructureDeviceAddressInfoKHR32
+typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
-} VkAccelerationStructureDeviceAddressInfoKHR32;
+    VkBool32 shaderQuadControl;
+} VkPhysicalDeviceShaderQuadControlFeaturesKHR32;

-typedef struct VkAccelerationStructureMemoryRequirementsInfoNV32
+typedef struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAccelerationStructureMemoryRequirementsTypeNV type;
-    VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
-} VkAccelerationStructureMemoryRequirementsInfoNV32;
+    VkBool32 shaderRelaxedExtendedInstruction;
+} VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32;

-typedef struct VkMemoryRequirements32
+typedef struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32
 {
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-    VkDeviceSize DECLSPEC_ALIGN(8) alignment;
-    uint32_t memoryTypeBits;
-} VkMemoryRequirements32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 shaderReplicatedComposites;
+} VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32;

+typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 shaderSMBuiltins;
+} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32;

-typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT32
+typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
-    VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructureNV;
-} VkAccelerationStructureCaptureDescriptorDataInfoEXT32;
+    uint32_t shaderSMCount;
+    uint32_t shaderWarpsPerSM;
+} VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32;

-typedef struct VkBufferDeviceAddressInfo32
+typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-} VkBufferDeviceAddressInfo32;
-typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoKHR32;
-typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoEXT32;
+    VkBool32 shaderSubgroupExtendedTypes;
+} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32;
+typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR32;

-typedef struct VkBufferMemoryRequirementsInfo232
+typedef struct VkPhysicalDeviceShaderSubgroupRotateFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-} VkBufferMemoryRequirementsInfo232;
-typedef VkBufferMemoryRequirementsInfo232 VkBufferMemoryRequirementsInfo2KHR32;
+    VkBool32 shaderSubgroupRotate;
+    VkBool32 shaderSubgroupRotateClustered;
+} VkPhysicalDeviceShaderSubgroupRotateFeatures32;
+typedef VkPhysicalDeviceShaderSubgroupRotateFeatures32 VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR32;

-typedef struct VkMemoryDedicatedRequirements32
+typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 prefersDedicatedAllocation;
-    VkBool32 requiresDedicatedAllocation;
-} VkMemoryDedicatedRequirements32;
-typedef VkMemoryDedicatedRequirements32 VkMemoryDedicatedRequirementsKHR32;
+    VkBool32 shaderSubgroupUniformControlFlow;
+} VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32;

-typedef struct VkTileMemoryRequirementsQCOM32
+typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-    VkDeviceSize DECLSPEC_ALIGN(8) alignment;
-} VkTileMemoryRequirementsQCOM32;
+    VkBool32 shaderTerminateInvocation;
+} VkPhysicalDeviceShaderTerminateInvocationFeatures32;
+typedef VkPhysicalDeviceShaderTerminateInvocationFeatures32 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR32;

-typedef struct VkMemoryRequirements232
+typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
-} VkMemoryRequirements232;
-typedef VkMemoryRequirements232 VkMemoryRequirements2KHR32;
+    VkBool32 shaderTileImageColorReadAccess;
+    VkBool32 shaderTileImageDepthReadAccess;
+    VkBool32 shaderTileImageStencilReadAccess;
+} VkPhysicalDeviceShaderTileImageFeaturesEXT32;

-typedef struct VkBufferCaptureDescriptorDataInfoEXT32
+typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-} VkBufferCaptureDescriptorDataInfoEXT32;
+    VkBool32 shaderTileImageCoherentReadAccelerated;
+    VkBool32 shaderTileImageReadSampleFromPixelRateInvocation;
+    VkBool32 shaderTileImageReadFromHelperInvocation;
+} VkPhysicalDeviceShaderTileImagePropertiesEXT32;

-typedef struct VkCalibratedTimestampInfoKHR32
+typedef struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkTimeDomainKHR timeDomain;
-} VkCalibratedTimestampInfoKHR32;
-typedef VkCalibratedTimestampInfoKHR32 VkCalibratedTimestampInfoEXT32;
+    VkBool32 shaderUntypedPointers;
+} VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32;

-typedef struct VkDataGraphPipelineInfoARM32
+typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipeline DECLSPEC_ALIGN(8) dataGraphPipeline;
-} VkDataGraphPipelineInfoARM32;
+    VkBool32 shadingRateImage;
+    VkBool32 shadingRateCoarseSampleOrder;
+} VkPhysicalDeviceShadingRateImageFeaturesNV32;

-typedef struct VkDataGraphPipelinePropertyQueryResultARM32
+typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDataGraphPipelinePropertyARM property;
-    VkBool32 isText;
-    PTR32 dataSize;
-    PTR32 pData;
-} VkDataGraphPipelinePropertyQueryResultARM32;
+    VkExtent2D shadingRateTexelSize;
+    uint32_t shadingRatePaletteSize;
+    uint32_t shadingRateMaxCoarseSamples;
+} VkPhysicalDeviceShadingRateImagePropertiesNV32;

-typedef struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM32
+typedef struct VkPhysicalDeviceSparseImageFormatInfo232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session;
-} VkDataGraphPipelineSessionBindPointRequirementsInfoARM32;
+    VkFormat format;
+    VkImageType type;
+    VkSampleCountFlagBits samples;
+    VkImageUsageFlags usage;
+    VkImageTiling tiling;
+} VkPhysicalDeviceSparseImageFormatInfo232;
+typedef VkPhysicalDeviceSparseImageFormatInfo232 VkPhysicalDeviceSparseImageFormatInfo2KHR32;

-typedef struct VkDataGraphPipelineSessionBindPointRequirementARM32
+typedef struct VkPhysicalDeviceSubgroupProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDataGraphPipelineSessionBindPointARM bindPoint;
-    VkDataGraphPipelineSessionBindPointTypeARM bindPointType;
-    uint32_t numObjects;
-} VkDataGraphPipelineSessionBindPointRequirementARM32;
+    uint32_t subgroupSize;
+    VkShaderStageFlags supportedStages;
+    VkSubgroupFeatureFlags supportedOperations;
+    VkBool32 quadOperationsInAllStages;
+} VkPhysicalDeviceSubgroupProperties32;

-typedef struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM32
+typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session;
-    VkDataGraphPipelineSessionBindPointARM bindPoint;
-    uint32_t objectIndex;
-} VkDataGraphPipelineSessionMemoryRequirementsInfoARM32;
+    VkBool32 subgroupSizeControl;
+    VkBool32 computeFullSubgroups;
+} VkPhysicalDeviceSubgroupSizeControlFeatures32;
+typedef VkPhysicalDeviceSubgroupSizeControlFeatures32 VkPhysicalDeviceSubgroupSizeControlFeaturesEXT32;

-typedef struct VkDescriptorAddressInfoEXT32
+typedef struct VkPhysicalDeviceSubgroupSizeControlProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceAddress DECLSPEC_ALIGN(8) address;
-    VkDeviceSize DECLSPEC_ALIGN(8) range;
-    VkFormat format;
-} VkDescriptorAddressInfoEXT32;
+    uint32_t minSubgroupSize;
+    uint32_t maxSubgroupSize;
+    uint32_t maxComputeWorkgroupSubgroups;
+    VkShaderStageFlags requiredSubgroupSizeStages;
+} VkPhysicalDeviceSubgroupSizeControlProperties32;
+typedef VkPhysicalDeviceSubgroupSizeControlProperties32 VkPhysicalDeviceSubgroupSizeControlPropertiesEXT32;

-typedef union VkDescriptorDataEXT32
+typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32
 {
-    PTR32 pSampler;
-    PTR32 pCombinedImageSampler;
-    PTR32 pInputAttachmentImage;
-    PTR32 pSampledImage;
-    PTR32 pStorageImage;
-    PTR32 pUniformTexelBuffer;
-    PTR32 pStorageTexelBuffer;
-    PTR32 pUniformBuffer;
-    PTR32 pStorageBuffer;
-    VkDeviceAddress DECLSPEC_ALIGN(8) accelerationStructure;
-} VkDescriptorDataEXT32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 subpassMergeFeedback;
+} VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32;

-typedef struct VkDescriptorGetTensorInfoARM32
+typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkTensorViewARM DECLSPEC_ALIGN(8) tensorView;
-} VkDescriptorGetTensorInfoARM32;
+    VkBool32 subpassShading;
+} VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32;

-typedef struct VkDescriptorGetInfoEXT32
+typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDescriptorType type;
-    VkDescriptorDataEXT32 DECLSPEC_ALIGN(8) data;
-} VkDescriptorGetInfoEXT32;
+    uint32_t maxSubpassShadingWorkgroupSizeAspectRatio;
+} VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32;

-typedef struct VkDescriptorSetBindingReferenceVALVE32
+typedef struct VkPhysicalDeviceSurfaceInfo2KHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
-    uint32_t binding;
-} VkDescriptorSetBindingReferenceVALVE32;
+    VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
+} VkPhysicalDeviceSurfaceInfo2KHR32;

-typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE32
+typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 descriptorOffset;
-    uint32_t descriptorSize;
-} VkDescriptorSetLayoutHostMappingInfoVALVE32;
+    VkBool32 swapchainMaintenance1;
+} VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32;
+typedef VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32;

-typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport32
+typedef struct VkPhysicalDeviceSynchronization2Features32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxVariableDescriptorCount;
-} VkDescriptorSetVariableDescriptorCountLayoutSupport32;
-typedef VkDescriptorSetVariableDescriptorCountLayoutSupport32 VkDescriptorSetVariableDescriptorCountLayoutSupportEXT32;
+    VkBool32 synchronization2;
+} VkPhysicalDeviceSynchronization2Features32;
+typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronization2FeaturesKHR32;

-typedef struct VkDescriptorSetLayoutSupport32
+typedef struct VkPhysicalDeviceTensorFeaturesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 supported;
-} VkDescriptorSetLayoutSupport32;
-typedef VkDescriptorSetLayoutSupport32 VkDescriptorSetLayoutSupportKHR32;
+    VkBool32 tensorNonPacked;
+    VkBool32 shaderTensorAccess;
+    VkBool32 shaderStorageTensorArrayDynamicIndexing;
+    VkBool32 shaderStorageTensorArrayNonUniformIndexing;
+    VkBool32 descriptorBindingStorageTensorUpdateAfterBind;
+    VkBool32 tensors;
+} VkPhysicalDeviceTensorFeaturesARM32;

-typedef struct VkAccelerationStructureVersionInfoKHR32
+typedef struct VkPhysicalDeviceTensorPropertiesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pVersionData;
-} VkAccelerationStructureVersionInfoKHR32;
+    uint32_t maxTensorDimensionCount;
+    uint64_t DECLSPEC_ALIGN(8) maxTensorElements;
+    uint64_t DECLSPEC_ALIGN(8) maxPerDimensionTensorElements;
+    int64_t maxTensorStride;
+    uint64_t DECLSPEC_ALIGN(8) maxTensorSize;
+    uint32_t maxTensorShaderAccessArrayLength;
+    uint32_t maxTensorShaderAccessSize;
+    uint32_t maxDescriptorSetStorageTensors;
+    uint32_t maxPerStageDescriptorSetStorageTensors;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageTensors;
+    uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors;
+    VkBool32 shaderStorageTensorArrayNonUniformIndexingNative;
+    VkShaderStageFlags shaderTensorSupportedStages;
+} VkPhysicalDeviceTensorPropertiesARM32;

-typedef struct VkDeviceBufferMemoryRequirements32
+typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pCreateInfo;
-} VkDeviceBufferMemoryRequirements32;
-typedef VkDeviceBufferMemoryRequirements32 VkDeviceBufferMemoryRequirementsKHR32;
+    VkBool32 texelBufferAlignment;
+} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32;

-typedef struct VkDeviceFaultCountsEXT32
+typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t addressInfoCount;
-    uint32_t vendorInfoCount;
-    VkDeviceSize DECLSPEC_ALIGN(8) vendorBinarySize;
-} VkDeviceFaultCountsEXT32;
+    VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
+    VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
+    VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
+    VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
+} VkPhysicalDeviceTexelBufferAlignmentProperties32;
+typedef VkPhysicalDeviceTexelBufferAlignmentProperties32 VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT32;

-typedef struct VkDeviceFaultAddressInfoEXT32
+typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures32
 {
-    VkDeviceFaultAddressTypeEXT addressType;
-    VkDeviceAddress DECLSPEC_ALIGN(8) reportedAddress;
-    VkDeviceSize DECLSPEC_ALIGN(8) addressPrecision;
-} VkDeviceFaultAddressInfoEXT32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 textureCompressionASTC_HDR;
+} VkPhysicalDeviceTextureCompressionASTCHDRFeatures32;
+typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT32;

-typedef struct VkDeviceFaultVendorInfoEXT32
+typedef struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32
 {
-    char description[VK_MAX_DESCRIPTION_SIZE];
-    uint64_t DECLSPEC_ALIGN(8) vendorFaultCode;
-    uint64_t DECLSPEC_ALIGN(8) vendorFaultData;
-} VkDeviceFaultVendorInfoEXT32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 tileMemoryHeap;
+} VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32;
+
+typedef struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 queueSubmitBoundary;
+    VkBool32 tileBufferTransfers;
+} VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32;

-typedef struct VkDeviceFaultInfoEXT32
+typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    char description[VK_MAX_DESCRIPTION_SIZE];
-    PTR32 pAddressInfos;
-    PTR32 pVendorInfos;
-    PTR32 pVendorBinaryData;
-} VkDeviceFaultInfoEXT32;
+    VkBool32 tileProperties;
+} VkPhysicalDeviceTilePropertiesFeaturesQCOM32;

-typedef struct VkDeviceGroupPresentCapabilitiesKHR32
+typedef struct VkPhysicalDeviceTileShadingFeaturesQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
-    VkDeviceGroupPresentModeFlagsKHR modes;
-} VkDeviceGroupPresentCapabilitiesKHR32;
+    VkBool32 tileShading;
+    VkBool32 tileShadingFragmentStage;
+    VkBool32 tileShadingColorAttachments;
+    VkBool32 tileShadingDepthAttachments;
+    VkBool32 tileShadingStencilAttachments;
+    VkBool32 tileShadingInputAttachments;
+    VkBool32 tileShadingSampledAttachments;
+    VkBool32 tileShadingPerTileDraw;
+    VkBool32 tileShadingPerTileDispatch;
+    VkBool32 tileShadingDispatchTile;
+    VkBool32 tileShadingApron;
+    VkBool32 tileShadingAnisotropicApron;
+    VkBool32 tileShadingAtomicOps;
+    VkBool32 tileShadingImageProcessing;
+} VkPhysicalDeviceTileShadingFeaturesQCOM32;

-typedef struct VkDeviceImageMemoryRequirements32
+typedef struct VkPhysicalDeviceTileShadingPropertiesQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pCreateInfo;
-    VkImageAspectFlagBits planeAspect;
-} VkDeviceImageMemoryRequirements32;
-typedef VkDeviceImageMemoryRequirements32 VkDeviceImageMemoryRequirementsKHR32;
+    uint32_t maxApronSize;
+    VkBool32 preferNonCoherent;
+    VkExtent2D tileGranularity;
+    VkExtent2D maxTileShadingRate;
+} VkPhysicalDeviceTileShadingPropertiesQCOM32;

-typedef struct VkSparseImageMemoryRequirements32
+typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures32
 {
-    VkSparseImageFormatProperties formatProperties;
-    uint32_t imageMipTailFirstLod;
-    VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailSize;
-    VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailOffset;
-    VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailStride;
-} VkSparseImageMemoryRequirements32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 timelineSemaphore;
+} VkPhysicalDeviceTimelineSemaphoreFeatures32;
+typedef VkPhysicalDeviceTimelineSemaphoreFeatures32 VkPhysicalDeviceTimelineSemaphoreFeaturesKHR32;

-typedef struct VkSparseImageMemoryRequirements232
+typedef struct VkPhysicalDeviceTimelineSemaphoreProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSparseImageMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
-} VkSparseImageMemoryRequirements232;
-typedef VkSparseImageMemoryRequirements232 VkSparseImageMemoryRequirements2KHR32;
+    uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
+} VkPhysicalDeviceTimelineSemaphoreProperties32;
+typedef VkPhysicalDeviceTimelineSemaphoreProperties32 VkPhysicalDeviceTimelineSemaphorePropertiesKHR32;

-typedef struct VkImageSubresource232
+typedef struct VkPhysicalDeviceToolProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageSubresource imageSubresource;
-} VkImageSubresource232;
-typedef VkImageSubresource232 VkImageSubresource2KHR32;
-typedef VkImageSubresource232 VkImageSubresource2EXT32;
+    char name[VK_MAX_EXTENSION_NAME_SIZE];
+    char version[VK_MAX_EXTENSION_NAME_SIZE];
+    VkToolPurposeFlags purposes;
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    char layer[VK_MAX_EXTENSION_NAME_SIZE];
+} VkPhysicalDeviceToolProperties32;
+typedef VkPhysicalDeviceToolProperties32 VkPhysicalDeviceToolPropertiesEXT32;

-typedef struct VkDeviceImageSubresourceInfo32
+typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pCreateInfo;
-    PTR32 pSubresource;
-} VkDeviceImageSubresourceInfo32;
-typedef VkDeviceImageSubresourceInfo32 VkDeviceImageSubresourceInfoKHR32;
+    VkBool32 transformFeedback;
+    VkBool32 geometryStreams;
+} VkPhysicalDeviceTransformFeedbackFeaturesEXT32;

-typedef struct VkSubresourceLayout32
+typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT32
 {
-    VkDeviceSize DECLSPEC_ALIGN(8) offset;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-    VkDeviceSize DECLSPEC_ALIGN(8) rowPitch;
-    VkDeviceSize DECLSPEC_ALIGN(8) arrayPitch;
-    VkDeviceSize DECLSPEC_ALIGN(8) depthPitch;
-} VkSubresourceLayout32;
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t maxTransformFeedbackStreams;
+    uint32_t maxTransformFeedbackBuffers;
+    VkDeviceSize DECLSPEC_ALIGN(8) maxTransformFeedbackBufferSize;
+    uint32_t maxTransformFeedbackStreamDataSize;
+    uint32_t maxTransformFeedbackBufferDataSize;
+    uint32_t maxTransformFeedbackBufferDataStride;
+    VkBool32 transformFeedbackQueries;
+    VkBool32 transformFeedbackStreamsLinesTriangles;
+    VkBool32 transformFeedbackRasterizationStreamSelect;
+    VkBool32 transformFeedbackDraw;
+} VkPhysicalDeviceTransformFeedbackPropertiesEXT32;

-typedef struct VkSubresourceHostMemcpySize32
+typedef struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-} VkSubresourceHostMemcpySize32;
-typedef VkSubresourceHostMemcpySize32 VkSubresourceHostMemcpySizeEXT32;
+    VkBool32 unifiedImageLayouts;
+    VkBool32 unifiedImageLayoutsVideo;
+} VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32;

-typedef struct VkImageCompressionPropertiesEXT32
+typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageCompressionFlagsEXT imageCompressionFlags;
-    VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags;
-} VkImageCompressionPropertiesEXT32;
+    VkBool32 uniformBufferStandardLayout;
+} VkPhysicalDeviceUniformBufferStandardLayoutFeatures32;
+typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR32;

-typedef struct VkSubresourceLayout232
+typedef struct VkPhysicalDeviceVariablePointersFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSubresourceLayout32 DECLSPEC_ALIGN(8) subresourceLayout;
-} VkSubresourceLayout232;
-typedef VkSubresourceLayout232 VkSubresourceLayout2KHR32;
-typedef VkSubresourceLayout232 VkSubresourceLayout2EXT32;
+    VkBool32 variablePointersStorageBuffer;
+    VkBool32 variablePointers;
+} VkPhysicalDeviceVariablePointersFeatures32;
+typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointersFeaturesKHR32;
+typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeaturesKHR32;
+typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeatures32;

-typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo32
+typedef struct VkPhysicalDeviceVertexAttributeDivisorFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
-} VkDeviceMemoryOpaqueCaptureAddressInfo32;
-typedef VkDeviceMemoryOpaqueCaptureAddressInfo32 VkDeviceMemoryOpaqueCaptureAddressInfoKHR32;
+    VkBool32 vertexAttributeInstanceRateDivisor;
+    VkBool32 vertexAttributeInstanceRateZeroDivisor;
+} VkPhysicalDeviceVertexAttributeDivisorFeatures32;
+typedef VkPhysicalDeviceVertexAttributeDivisorFeatures32 VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR32;
+typedef VkPhysicalDeviceVertexAttributeDivisorFeatures32 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32;

-typedef struct VkMicromapVersionInfoEXT32
+typedef struct VkPhysicalDeviceVertexAttributeDivisorProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pVersionData;
-} VkMicromapVersionInfoEXT32;
+    uint32_t maxVertexAttribDivisor;
+    VkBool32 supportsNonZeroFirstInstance;
+} VkPhysicalDeviceVertexAttributeDivisorProperties32;
+typedef VkPhysicalDeviceVertexAttributeDivisorProperties32 VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR32;

-typedef struct VkDeviceQueueInfo232
+typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceQueueCreateFlags flags;
-    uint32_t queueFamilyIndex;
-    uint32_t queueIndex;
-} VkDeviceQueueInfo232;
+    uint32_t maxVertexAttribDivisor;
+} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32;

-typedef struct VkDeviceTensorMemoryRequirementsARM32
+typedef struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pCreateInfo;
-} VkDeviceTensorMemoryRequirementsARM32;
+    VkBool32 vertexAttributeRobustness;
+} VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32;

-typedef struct VkTilePropertiesQCOM32
+typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExtent3D tileSize;
-    VkExtent2D apronSize;
-    VkOffset2D origin;
-} VkTilePropertiesQCOM32;
+    VkBool32 vertexInputDynamicState;
+} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32;

-typedef struct VkVideoEncodeH264SessionParametersGetInfoKHR32
+typedef struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 writeStdSPS;
-    VkBool32 writeStdPPS;
-    uint32_t stdSPSId;
-    uint32_t stdPPSId;
-} VkVideoEncodeH264SessionParametersGetInfoKHR32;
+    VkBool32 videoDecodeVP9;
+} VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32;

-typedef struct VkVideoEncodeSessionParametersGetInfoKHR32
+typedef struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoSessionParametersKHR DECLSPEC_ALIGN(8) videoSessionParameters;
-} VkVideoEncodeSessionParametersGetInfoKHR32;
+    VkBool32 videoEncodeAV1;
+} VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32;

-typedef struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR32
+typedef struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 hasStdSPSOverrides;
-    VkBool32 hasStdPPSOverrides;
-} VkVideoEncodeH264SessionParametersFeedbackInfoKHR32;
+    VkBool32 videoEncodeIntraRefresh;
+} VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32;

-typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR32
+typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 hasOverrides;
-} VkVideoEncodeSessionParametersFeedbackInfoKHR32;
+    PTR32 pVideoProfile;
+    uint32_t qualityLevel;
+} VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR32;

-typedef struct VkGeneratedCommandsMemoryRequirementsInfoEXT32
+typedef struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet;
-    VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout;
-    uint32_t maxSequenceCount;
-    uint32_t maxDrawCount;
-} VkGeneratedCommandsMemoryRequirementsInfoEXT32;
+    VkBool32 videoEncodeQuantizationMap;
+} VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32;

-typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32
+typedef struct VkPhysicalDeviceVideoFormatInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineBindPoint pipelineBindPoint;
-    VkPipeline DECLSPEC_ALIGN(8) pipeline;
-    VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
-    uint32_t maxSequencesCount;
-} VkGeneratedCommandsMemoryRequirementsInfoNV32;
+    VkImageUsageFlags imageUsage;
+} VkPhysicalDeviceVideoFormatInfoKHR32;

-typedef struct VkImagePlaneMemoryRequirementsInfo32
+typedef struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageAspectFlagBits planeAspect;
-} VkImagePlaneMemoryRequirementsInfo32;
-typedef VkImagePlaneMemoryRequirementsInfo32 VkImagePlaneMemoryRequirementsInfoKHR32;
+    VkBool32 videoMaintenance1;
+} VkPhysicalDeviceVideoMaintenance1FeaturesKHR32;

-typedef struct VkImageMemoryRequirementsInfo232
+typedef struct VkPhysicalDeviceVulkan11Features32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImage DECLSPEC_ALIGN(8) image;
-} VkImageMemoryRequirementsInfo232;
-typedef VkImageMemoryRequirementsInfo232 VkImageMemoryRequirementsInfo2KHR32;
+    VkBool32 storageBuffer16BitAccess;
+    VkBool32 uniformAndStorageBuffer16BitAccess;
+    VkBool32 storagePushConstant16;
+    VkBool32 storageInputOutput16;
+    VkBool32 multiview;
+    VkBool32 multiviewGeometryShader;
+    VkBool32 multiviewTessellationShader;
+    VkBool32 variablePointersStorageBuffer;
+    VkBool32 variablePointers;
+    VkBool32 protectedMemory;
+    VkBool32 samplerYcbcrConversion;
+    VkBool32 shaderDrawParameters;
+} VkPhysicalDeviceVulkan11Features32;

-typedef struct VkImageCaptureDescriptorDataInfoEXT32
+typedef struct VkPhysicalDeviceVulkan11Properties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImage DECLSPEC_ALIGN(8) image;
-} VkImageCaptureDescriptorDataInfoEXT32;
+    uint8_t deviceUUID[VK_UUID_SIZE];
+    uint8_t driverUUID[VK_UUID_SIZE];
+    uint8_t deviceLUID[VK_LUID_SIZE];
+    uint32_t deviceNodeMask;
+    VkBool32 deviceLUIDValid;
+    uint32_t subgroupSize;
+    VkShaderStageFlags subgroupSupportedStages;
+    VkSubgroupFeatureFlags subgroupSupportedOperations;
+    VkBool32 subgroupQuadOperationsInAllStages;
+    VkPointClippingBehavior pointClippingBehavior;
+    uint32_t maxMultiviewViewCount;
+    uint32_t maxMultiviewInstanceIndex;
+    VkBool32 protectedNoFault;
+    uint32_t maxPerSetDescriptors;
+    VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
+} VkPhysicalDeviceVulkan11Properties32;

-typedef struct VkImageSparseMemoryRequirementsInfo232
+typedef struct VkPhysicalDeviceVulkan12Features32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImage DECLSPEC_ALIGN(8) image;
-} VkImageSparseMemoryRequirementsInfo232;
-typedef VkImageSparseMemoryRequirementsInfo232 VkImageSparseMemoryRequirementsInfo2KHR32;
+    VkBool32 samplerMirrorClampToEdge;
+    VkBool32 drawIndirectCount;
+    VkBool32 storageBuffer8BitAccess;
+    VkBool32 uniformAndStorageBuffer8BitAccess;
+    VkBool32 storagePushConstant8;
+    VkBool32 shaderBufferInt64Atomics;
+    VkBool32 shaderSharedInt64Atomics;
+    VkBool32 shaderFloat16;
+    VkBool32 shaderInt8;
+    VkBool32 descriptorIndexing;
+    VkBool32 shaderInputAttachmentArrayDynamicIndexing;
+    VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
+    VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
+    VkBool32 shaderUniformBufferArrayNonUniformIndexing;
+    VkBool32 shaderSampledImageArrayNonUniformIndexing;
+    VkBool32 shaderStorageBufferArrayNonUniformIndexing;
+    VkBool32 shaderStorageImageArrayNonUniformIndexing;
+    VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
+    VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
+    VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
+    VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
+    VkBool32 descriptorBindingSampledImageUpdateAfterBind;
+    VkBool32 descriptorBindingStorageImageUpdateAfterBind;
+    VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
+    VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
+    VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
+    VkBool32 descriptorBindingUpdateUnusedWhilePending;
+    VkBool32 descriptorBindingPartiallyBound;
+    VkBool32 descriptorBindingVariableDescriptorCount;
+    VkBool32 runtimeDescriptorArray;
+    VkBool32 samplerFilterMinmax;
+    VkBool32 scalarBlockLayout;
+    VkBool32 imagelessFramebuffer;
+    VkBool32 uniformBufferStandardLayout;
+    VkBool32 shaderSubgroupExtendedTypes;
+    VkBool32 separateDepthStencilLayouts;
+    VkBool32 hostQueryReset;
+    VkBool32 timelineSemaphore;
+    VkBool32 bufferDeviceAddress;
+    VkBool32 bufferDeviceAddressCaptureReplay;
+    VkBool32 bufferDeviceAddressMultiDevice;
+    VkBool32 vulkanMemoryModel;
+    VkBool32 vulkanMemoryModelDeviceScope;
+    VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
+    VkBool32 shaderOutputViewportIndex;
+    VkBool32 shaderOutputLayer;
+    VkBool32 subgroupBroadcastDynamicId;
+} VkPhysicalDeviceVulkan12Features32;

-typedef struct VkImageViewAddressPropertiesNVX32
+typedef struct VkPhysicalDeviceVulkan12Properties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-} VkImageViewAddressPropertiesNVX32;
+    VkDriverId driverID;
+    char driverName[VK_MAX_DRIVER_NAME_SIZE];
+    char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
+    VkConformanceVersion conformanceVersion;
+    VkShaderFloatControlsIndependence denormBehaviorIndependence;
+    VkShaderFloatControlsIndependence roundingModeIndependence;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat16;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat32;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat64;
+    VkBool32 shaderDenormPreserveFloat16;
+    VkBool32 shaderDenormPreserveFloat32;
+    VkBool32 shaderDenormPreserveFloat64;
+    VkBool32 shaderDenormFlushToZeroFloat16;
+    VkBool32 shaderDenormFlushToZeroFloat32;
+    VkBool32 shaderDenormFlushToZeroFloat64;
+    VkBool32 shaderRoundingModeRTEFloat16;
+    VkBool32 shaderRoundingModeRTEFloat32;
+    VkBool32 shaderRoundingModeRTEFloat64;
+    VkBool32 shaderRoundingModeRTZFloat16;
+    VkBool32 shaderRoundingModeRTZFloat32;
+    VkBool32 shaderRoundingModeRTZFloat64;
+    uint32_t maxUpdateAfterBindDescriptorsInAllPools;
+    VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
+    VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
+    VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
+    VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
+    VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
+    VkBool32 robustBufferAccessUpdateAfterBind;
+    VkBool32 quadDivergentImplicitLod;
+    uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
+    uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
+    uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    uint32_t maxPerStageUpdateAfterBindResources;
+    uint32_t maxDescriptorSetUpdateAfterBindSamplers;
+    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
+    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
+    uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
+    VkResolveModeFlags supportedDepthResolveModes;
+    VkResolveModeFlags supportedStencilResolveModes;
+    VkBool32 independentResolveNone;
+    VkBool32 independentResolve;
+    VkBool32 filterMinmaxSingleComponentFormats;
+    VkBool32 filterMinmaxImageComponentMapping;
+    uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
+    VkSampleCountFlags framebufferIntegerColorSampleCounts;
+} VkPhysicalDeviceVulkan12Properties32;

-typedef struct VkImageViewHandleInfoNVX32
+typedef struct VkPhysicalDeviceVulkan13Features32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageView DECLSPEC_ALIGN(8) imageView;
-    VkDescriptorType descriptorType;
-    VkSampler DECLSPEC_ALIGN(8) sampler;
-} VkImageViewHandleInfoNVX32;
+    VkBool32 robustImageAccess;
+    VkBool32 inlineUniformBlock;
+    VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
+    VkBool32 pipelineCreationCacheControl;
+    VkBool32 privateData;
+    VkBool32 shaderDemoteToHelperInvocation;
+    VkBool32 shaderTerminateInvocation;
+    VkBool32 subgroupSizeControl;
+    VkBool32 computeFullSubgroups;
+    VkBool32 synchronization2;
+    VkBool32 textureCompressionASTC_HDR;
+    VkBool32 shaderZeroInitializeWorkgroupMemory;
+    VkBool32 dynamicRendering;
+    VkBool32 shaderIntegerDotProduct;
+    VkBool32 maintenance4;
+} VkPhysicalDeviceVulkan13Features32;

-typedef struct VkImageViewCaptureDescriptorDataInfoEXT32
+typedef struct VkPhysicalDeviceVulkan13Properties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageView DECLSPEC_ALIGN(8) imageView;
-} VkImageViewCaptureDescriptorDataInfoEXT32;
+    uint32_t minSubgroupSize;
+    uint32_t maxSubgroupSize;
+    uint32_t maxComputeWorkgroupSubgroups;
+    VkShaderStageFlags requiredSubgroupSizeStages;
+    uint32_t maxInlineUniformBlockSize;
+    uint32_t maxPerStageDescriptorInlineUniformBlocks;
+    uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    uint32_t maxDescriptorSetInlineUniformBlocks;
+    uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    uint32_t maxInlineUniformTotalSize;
+    VkBool32 integerDotProduct8BitUnsignedAccelerated;
+    VkBool32 integerDotProduct8BitSignedAccelerated;
+    VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+    VkBool32 integerDotProduct16BitUnsignedAccelerated;
+    VkBool32 integerDotProduct16BitSignedAccelerated;
+    VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct32BitUnsignedAccelerated;
+    VkBool32 integerDotProduct32BitSignedAccelerated;
+    VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct64BitUnsignedAccelerated;
+    VkBool32 integerDotProduct64BitSignedAccelerated;
+    VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+    VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
+    VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
+    VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
+    VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
+    VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
+} VkPhysicalDeviceVulkan13Properties32;

-typedef struct VkLatencyTimingsFrameReportNV32
+typedef struct VkPhysicalDeviceVulkan14Features32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint64_t DECLSPEC_ALIGN(8) presentID;
-    uint64_t DECLSPEC_ALIGN(8) inputSampleTimeUs;
-    uint64_t DECLSPEC_ALIGN(8) simStartTimeUs;
-    uint64_t DECLSPEC_ALIGN(8) simEndTimeUs;
-    uint64_t DECLSPEC_ALIGN(8) renderSubmitStartTimeUs;
-    uint64_t DECLSPEC_ALIGN(8) renderSubmitEndTimeUs;
-    uint64_t DECLSPEC_ALIGN(8) presentStartTimeUs;
-    uint64_t DECLSPEC_ALIGN(8) presentEndTimeUs;
-    uint64_t DECLSPEC_ALIGN(8) driverStartTimeUs;
-    uint64_t DECLSPEC_ALIGN(8) driverEndTimeUs;
-    uint64_t DECLSPEC_ALIGN(8) osRenderQueueStartTimeUs;
-    uint64_t DECLSPEC_ALIGN(8) osRenderQueueEndTimeUs;
-    uint64_t DECLSPEC_ALIGN(8) gpuRenderStartTimeUs;
-    uint64_t DECLSPEC_ALIGN(8) gpuRenderEndTimeUs;
-} VkLatencyTimingsFrameReportNV32;
+    VkBool32 globalPriorityQuery;
+    VkBool32 shaderSubgroupRotate;
+    VkBool32 shaderSubgroupRotateClustered;
+    VkBool32 shaderFloatControls2;
+    VkBool32 shaderExpectAssume;
+    VkBool32 rectangularLines;
+    VkBool32 bresenhamLines;
+    VkBool32 smoothLines;
+    VkBool32 stippledRectangularLines;
+    VkBool32 stippledBresenhamLines;
+    VkBool32 stippledSmoothLines;
+    VkBool32 vertexAttributeInstanceRateDivisor;
+    VkBool32 vertexAttributeInstanceRateZeroDivisor;
+    VkBool32 indexTypeUint8;
+    VkBool32 dynamicRenderingLocalRead;
+    VkBool32 maintenance5;
+    VkBool32 maintenance6;
+    VkBool32 pipelineProtectedAccess;
+    VkBool32 pipelineRobustness;
+    VkBool32 hostImageCopy;
+    VkBool32 pushDescriptor;
+} VkPhysicalDeviceVulkan14Features32;

-typedef struct VkGetLatencyMarkerInfoNV32
+typedef struct VkPhysicalDeviceVulkan14Properties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t timingCount;
-    PTR32 pTimings;
-} VkGetLatencyMarkerInfoNV32;
+    uint32_t lineSubPixelPrecisionBits;
+    uint32_t maxVertexAttribDivisor;
+    VkBool32 supportsNonZeroFirstInstance;
+    uint32_t maxPushDescriptors;
+    VkBool32 dynamicRenderingLocalReadDepthStencilAttachments;
+    VkBool32 dynamicRenderingLocalReadMultisampledAttachments;
+    VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting;
+    VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting;
+    VkBool32 depthStencilSwizzleOneSupport;
+    VkBool32 polygonModePointSize;
+    VkBool32 nonStrictSinglePixelWideLinesUseParallelogram;
+    VkBool32 nonStrictWideLinesUseParallelogram;
+    VkBool32 blockTexelViewCompatibleMultipleLayers;
+    uint32_t maxCombinedImageSamplerDescriptorCount;
+    VkBool32 fragmentShadingRateClampCombinerInputs;
+    VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers;
+    VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers;
+    VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs;
+    VkPipelineRobustnessImageBehavior defaultRobustnessImages;
+    uint32_t copySrcLayoutCount;
+    PTR32 pCopySrcLayouts;
+    uint32_t copyDstLayoutCount;
+    PTR32 pCopyDstLayouts;
+    uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE];
+    VkBool32 identicalMemoryTypeRequirements;
+} VkPhysicalDeviceVulkan14Properties32;

-typedef struct VkMemoryHostPointerPropertiesEXT32
+typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t memoryTypeBits;
-} VkMemoryHostPointerPropertiesEXT32;
+    VkBool32 vulkanMemoryModel;
+    VkBool32 vulkanMemoryModelDeviceScope;
+    VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
+} VkPhysicalDeviceVulkanMemoryModelFeatures32;
+typedef VkPhysicalDeviceVulkanMemoryModelFeatures32 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR32;

-typedef struct VkMicromapBuildSizesInfoEXT32
+typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) micromapSize;
-    VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
-    VkBool32 discardable;
-} VkMicromapBuildSizesInfoEXT32;
-
-typedef union VkPerformanceValueDataINTEL32
-{
-    uint32_t value32;
-    uint64_t DECLSPEC_ALIGN(8) value64;
-    float valueFloat;
-    VkBool32 valueBool;
-    PTR32 valueString;
-} VkPerformanceValueDataINTEL32;
-
-typedef struct VkPerformanceValueINTEL32
-{
-    VkPerformanceValueTypeINTEL type;
-    VkPerformanceValueDataINTEL32 DECLSPEC_ALIGN(8) data;
-} VkPerformanceValueINTEL32;
+    VkBool32 workgroupMemoryExplicitLayout;
+    VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout;
+    VkBool32 workgroupMemoryExplicitLayout8BitAccess;
+    VkBool32 workgroupMemoryExplicitLayout16BitAccess;
+} VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32;

-typedef struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV32
+typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t MGranularity;
-    uint32_t NGranularity;
-    uint32_t KGranularity;
-    VkComponentTypeKHR AType;
-    VkComponentTypeKHR BType;
-    VkComponentTypeKHR CType;
-    VkComponentTypeKHR ResultType;
-    VkBool32 saturatingAccumulation;
-    VkScopeKHR scope;
-    uint32_t workgroupInvocations;
-} VkCooperativeMatrixFlexibleDimensionsPropertiesNV32;
+    VkBool32 ycbcr2plane444Formats;
+} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32;

-typedef struct VkCooperativeMatrixPropertiesKHR32
+typedef struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t MSize;
-    uint32_t NSize;
-    uint32_t KSize;
-    VkComponentTypeKHR AType;
-    VkComponentTypeKHR BType;
-    VkComponentTypeKHR CType;
-    VkComponentTypeKHR ResultType;
-    VkBool32 saturatingAccumulation;
-    VkScopeKHR scope;
-} VkCooperativeMatrixPropertiesKHR32;
+    VkBool32 ycbcrDegamma;
+} VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32;

-typedef struct VkCooperativeMatrixPropertiesNV32
+typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t MSize;
-    uint32_t NSize;
-    uint32_t KSize;
-    VkComponentTypeNV AType;
-    VkComponentTypeNV BType;
-    VkComponentTypeNV CType;
-    VkComponentTypeNV DType;
-    VkScopeNV scope;
-} VkCooperativeMatrixPropertiesNV32;
+    VkBool32 ycbcrImageArrays;
+} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32;

-typedef struct VkCooperativeVectorPropertiesNV32
+typedef struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkComponentTypeKHR inputType;
-    VkComponentTypeKHR inputInterpretation;
-    VkComponentTypeKHR matrixInterpretation;
-    VkComponentTypeKHR biasInterpretation;
-    VkComponentTypeKHR resultType;
-    VkBool32 transpose;
-} VkCooperativeVectorPropertiesNV32;
+    VkBool32 zeroInitializeDeviceMemory;
+} VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32;

-typedef struct VkPhysicalDeviceExternalBufferInfo32
+typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBufferCreateFlags flags;
-    VkBufferUsageFlags usage;
-    VkExternalMemoryHandleTypeFlagBits handleType;
-} VkPhysicalDeviceExternalBufferInfo32;
-typedef VkPhysicalDeviceExternalBufferInfo32 VkPhysicalDeviceExternalBufferInfoKHR32;
+    VkBool32 shaderZeroInitializeWorkgroupMemory;
+} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32;
+typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR32;

-typedef struct VkExternalBufferProperties32
+typedef struct VkPipelineBinaryCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalMemoryProperties externalMemoryProperties;
-} VkExternalBufferProperties32;
-typedef VkExternalBufferProperties32 VkExternalBufferPropertiesKHR32;
+    PTR32 pKeysAndDataInfo;
+    VkPipeline DECLSPEC_ALIGN(8) pipeline;
+    PTR32 pPipelineCreateInfo;
+} VkPipelineBinaryCreateInfoKHR32;

-typedef struct VkPhysicalDeviceExternalFenceInfo32
+typedef struct VkPipelineBinaryDataInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalFenceHandleTypeFlagBits handleType;
-} VkPhysicalDeviceExternalFenceInfo32;
-typedef VkPhysicalDeviceExternalFenceInfo32 VkPhysicalDeviceExternalFenceInfoKHR32;
+    VkPipelineBinaryKHR DECLSPEC_ALIGN(8) pipelineBinary;
+} VkPipelineBinaryDataInfoKHR32;

-typedef struct VkExternalFenceProperties32
+typedef struct VkPipelineBinaryHandlesInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
-    VkExternalFenceHandleTypeFlags compatibleHandleTypes;
-    VkExternalFenceFeatureFlags externalFenceFeatures;
-} VkExternalFenceProperties32;
-typedef VkExternalFenceProperties32 VkExternalFencePropertiesKHR32;
+    uint32_t pipelineBinaryCount;
+    PTR32 pPipelineBinaries;
+} VkPipelineBinaryHandlesInfoKHR32;

-typedef struct VkPhysicalDeviceExternalSemaphoreInfo32
+typedef struct VkPipelineBinaryInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalSemaphoreHandleTypeFlagBits handleType;
-} VkPhysicalDeviceExternalSemaphoreInfo32;
-typedef VkPhysicalDeviceExternalSemaphoreInfo32 VkPhysicalDeviceExternalSemaphoreInfoKHR32;
+    uint32_t binaryCount;
+    PTR32 pPipelineBinaries;
+} VkPipelineBinaryInfoKHR32;

-typedef struct VkExternalSemaphoreProperties32
+typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
-    VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
-    VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
-} VkExternalSemaphoreProperties32;
-typedef VkExternalSemaphoreProperties32 VkExternalSemaphorePropertiesKHR32;
+    VkBool32 srcPremultiplied;
+    VkBool32 dstPremultiplied;
+    VkBlendOverlapEXT blendOverlap;
+} VkPipelineColorBlendAdvancedStateCreateInfoEXT32;

-typedef struct VkPhysicalDeviceExternalTensorInfoARM32
+typedef struct VkPipelineColorWriteCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkTensorCreateFlagsARM DECLSPEC_ALIGN(8) flags;
-    PTR32 pDescription;
-    VkExternalMemoryHandleTypeFlagBits handleType;
-} VkPhysicalDeviceExternalTensorInfoARM32;
+    uint32_t attachmentCount;
+    PTR32 pColorWriteEnables;
+} VkPipelineColorWriteCreateInfoEXT32;

-typedef struct VkExternalTensorPropertiesARM32
+typedef struct VkPipelineCompilerControlCreateInfoAMD32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalMemoryProperties externalMemoryProperties;
-} VkExternalTensorPropertiesARM32;
+    VkPipelineCompilerControlFlagsAMD compilerControlFlags;
+} VkPipelineCompilerControlCreateInfoAMD32;

-typedef struct VkSubpassResolvePerformanceQueryEXT32
+typedef struct VkPipelineCoverageModulationStateCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 optimal;
-} VkSubpassResolvePerformanceQueryEXT32;
+    VkPipelineCoverageModulationStateCreateFlagsNV flags;
+    VkCoverageModulationModeNV coverageModulationMode;
+    VkBool32 coverageModulationTableEnable;
+    uint32_t coverageModulationTableCount;
+    PTR32 pCoverageModulationTable;
+} VkPipelineCoverageModulationStateCreateInfoNV32;

-typedef struct VkFormatProperties332
+typedef struct VkPipelineCoverageReductionStateCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingFeatures;
-    VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingFeatures;
-    VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) bufferFeatures;
-} VkFormatProperties332;
-typedef VkFormatProperties332 VkFormatProperties3KHR32;
+    VkPipelineCoverageReductionStateCreateFlagsNV flags;
+    VkCoverageReductionModeNV coverageReductionMode;
+} VkPipelineCoverageReductionStateCreateInfoNV32;

-typedef struct VkTensorFormatPropertiesARM32
+typedef struct VkPipelineCoverageToColorStateCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingTensorFeatures;
-    VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingTensorFeatures;
-} VkTensorFormatPropertiesARM32;
+    VkPipelineCoverageToColorStateCreateFlagsNV flags;
+    VkBool32 coverageToColorEnable;
+    uint32_t coverageToColorLocation;
+} VkPipelineCoverageToColorStateCreateInfoNV32;

-typedef struct VkFormatProperties232
+typedef struct VkPipelineCreateFlags2CreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkFormatProperties formatProperties;
-} VkFormatProperties232;
-typedef VkFormatProperties232 VkFormatProperties2KHR32;
+    VkPipelineCreateFlags2 DECLSPEC_ALIGN(8) flags;
+} VkPipelineCreateFlags2CreateInfo32;
+typedef VkPipelineCreateFlags2CreateInfo32 VkPipelineCreateFlags2CreateInfoKHR32;

-typedef struct VkPhysicalDeviceFragmentShadingRateKHR32
+typedef struct VkPipelineCreationFeedbackCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSampleCountFlags sampleCounts;
-    VkExtent2D fragmentSize;
-} VkPhysicalDeviceFragmentShadingRateKHR32;
-
-typedef struct VkImageFormatProperties32
-{
-    VkExtent3D maxExtent;
-    uint32_t maxMipLevels;
-    uint32_t maxArrayLayers;
-    VkSampleCountFlags sampleCounts;
-    VkDeviceSize DECLSPEC_ALIGN(8) maxResourceSize;
-} VkImageFormatProperties32;
+    PTR32 pPipelineCreationFeedback;
+    uint32_t pipelineStageCreationFeedbackCount;
+    PTR32 pPipelineStageCreationFeedbacks;
+} VkPipelineCreationFeedbackCreateInfo32;
+typedef VkPipelineCreationFeedbackCreateInfo32 VkPipelineCreationFeedbackCreateInfoEXT32;

-typedef struct VkPhysicalDeviceExternalImageFormatInfo32
+typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalMemoryHandleTypeFlagBits handleType;
-} VkPhysicalDeviceExternalImageFormatInfo32;
-typedef VkPhysicalDeviceExternalImageFormatInfo32 VkPhysicalDeviceExternalImageFormatInfoKHR32;
+    VkPipelineDiscardRectangleStateCreateFlagsEXT flags;
+    VkDiscardRectangleModeEXT discardRectangleMode;
+    uint32_t discardRectangleCount;
+    PTR32 pDiscardRectangles;
+} VkPipelineDiscardRectangleStateCreateInfoEXT32;

-typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT32
+typedef struct VkPipelineExecutableInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageViewType imageViewType;
-} VkPhysicalDeviceImageViewImageFormatInfoEXT32;
+    VkPipeline DECLSPEC_ALIGN(8) pipeline;
+    uint32_t executableIndex;
+} VkPipelineExecutableInfoKHR32;

-typedef struct VkPhysicalDeviceImageFormatInfo232
+typedef struct VkPipelineExecutableInternalRepresentationKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkFormat format;
-    VkImageType type;
-    VkImageTiling tiling;
-    VkImageUsageFlags usage;
-    VkImageCreateFlags flags;
-} VkPhysicalDeviceImageFormatInfo232;
-typedef VkPhysicalDeviceImageFormatInfo232 VkPhysicalDeviceImageFormatInfo2KHR32;
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    VkBool32 isText;
+    PTR32 dataSize;
+    PTR32 pData;
+} VkPipelineExecutableInternalRepresentationKHR32;

-typedef struct VkExternalImageFormatProperties32
+typedef struct VkPipelineExecutablePropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalMemoryProperties externalMemoryProperties;
-} VkExternalImageFormatProperties32;
-typedef VkExternalImageFormatProperties32 VkExternalImageFormatPropertiesKHR32;
+    VkShaderStageFlags stages;
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    uint32_t subgroupSize;
+} VkPipelineExecutablePropertiesKHR32;

-typedef struct VkSamplerYcbcrConversionImageFormatProperties32
+typedef struct VkPipelineExecutableStatisticKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t combinedImageSamplerDescriptorCount;
-} VkSamplerYcbcrConversionImageFormatProperties32;
-typedef VkSamplerYcbcrConversionImageFormatProperties32 VkSamplerYcbcrConversionImageFormatPropertiesKHR32;
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    VkPipelineExecutableStatisticFormatKHR format;
+    VkPipelineExecutableStatisticValueKHR32 DECLSPEC_ALIGN(8) value;
+} VkPipelineExecutableStatisticKHR32;

-typedef struct VkTextureLODGatherFormatPropertiesAMD32
+typedef struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 supportsTextureGatherLODBiasAMD;
-} VkTextureLODGatherFormatPropertiesAMD32;
+    uint32_t maxFragmentDensityMapLayers;
+} VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32;

-typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32
+typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 filterCubic;
-    VkBool32 filterCubicMinmax;
-} VkFilterCubicImageViewImageFormatPropertiesEXT32;
+    VkFragmentShadingRateTypeNV shadingRateType;
+    VkFragmentShadingRateNV shadingRate;
+    VkFragmentShadingRateCombinerOpKHR combinerOps[2];
+} VkPipelineFragmentShadingRateEnumStateCreateInfoNV32;

-typedef struct VkHostImageCopyDevicePerformanceQuery32
+typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 optimalDeviceAccess;
-    VkBool32 identicalMemoryLayout;
-} VkHostImageCopyDevicePerformanceQuery32;
-typedef VkHostImageCopyDevicePerformanceQuery32 VkHostImageCopyDevicePerformanceQueryEXT32;
+    VkExtent2D fragmentSize;
+    VkFragmentShadingRateCombinerOpKHR combinerOps[2];
+} VkPipelineFragmentShadingRateStateCreateInfoKHR32;

-typedef struct VkImageFormatProperties232
+typedef struct VkPipelineIndirectDeviceAddressInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageFormatProperties32 DECLSPEC_ALIGN(8) imageFormatProperties;
-} VkImageFormatProperties232;
-typedef VkImageFormatProperties232 VkImageFormatProperties2KHR32;
+    VkPipelineBindPoint pipelineBindPoint;
+    VkPipeline DECLSPEC_ALIGN(8) pipeline;
+} VkPipelineIndirectDeviceAddressInfoNV32;

-typedef struct VkMemoryHeap32
-{
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-    VkMemoryHeapFlags flags;
-} VkMemoryHeap32;

-typedef struct VkPhysicalDeviceMemoryProperties32
+typedef struct VkPipelineInfoKHR32
 {
-    uint32_t memoryTypeCount;
-    VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
-    uint32_t memoryHeapCount;
-    VkMemoryHeap32 DECLSPEC_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS];
-} VkPhysicalDeviceMemoryProperties32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkPipeline DECLSPEC_ALIGN(8) pipeline;
+} VkPipelineInfoKHR32;
+typedef VkPipelineInfoKHR32 VkPipelineInfoEXT32;

-typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT32
+typedef struct VkPipelineLayoutCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) heapBudget[VK_MAX_MEMORY_HEAPS];
-    VkDeviceSize DECLSPEC_ALIGN(8) heapUsage[VK_MAX_MEMORY_HEAPS];
-} VkPhysicalDeviceMemoryBudgetPropertiesEXT32;
+    VkPipelineLayoutCreateFlags flags;
+    uint32_t setLayoutCount;
+    PTR32 pSetLayouts;
+    uint32_t pushConstantRangeCount;
+    PTR32 pPushConstantRanges;
+} VkPipelineLayoutCreateInfo32;

-typedef struct VkPhysicalDeviceMemoryProperties232
+typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPhysicalDeviceMemoryProperties32 DECLSPEC_ALIGN(8) memoryProperties;
-} VkPhysicalDeviceMemoryProperties232;
-typedef VkPhysicalDeviceMemoryProperties232 VkPhysicalDeviceMemoryProperties2KHR32;
+    VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
+    VkConservativeRasterizationModeEXT conservativeRasterizationMode;
+    float extraPrimitiveOverestimationSize;
+} VkPipelineRasterizationConservativeStateCreateInfoEXT32;

-typedef struct VkMultisamplePropertiesEXT32
+typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExtent2D maxSampleLocationGridSize;
-} VkMultisamplePropertiesEXT32;
+    VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags;
+    VkBool32 depthClipEnable;
+} VkPipelineRasterizationDepthClipStateCreateInfoEXT32;

-typedef struct VkOpticalFlowImageFormatPropertiesNV32
+typedef struct VkPipelineRasterizationLineStateCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkFormat format;
-} VkOpticalFlowImageFormatPropertiesNV32;
+    VkLineRasterizationMode lineRasterizationMode;
+    VkBool32 stippledLineEnable;
+    uint32_t lineStippleFactor;
+    uint16_t lineStipplePattern;
+} VkPipelineRasterizationLineStateCreateInfo32;
+typedef VkPipelineRasterizationLineStateCreateInfo32 VkPipelineRasterizationLineStateCreateInfoKHR32;
+typedef VkPipelineRasterizationLineStateCreateInfo32 VkPipelineRasterizationLineStateCreateInfoEXT32;

-typedef struct VkPhysicalDeviceLimits32
+typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32
 {
-    uint32_t maxImageDimension1D;
-    uint32_t maxImageDimension2D;
-    uint32_t maxImageDimension3D;
-    uint32_t maxImageDimensionCube;
-    uint32_t maxImageArrayLayers;
-    uint32_t maxTexelBufferElements;
-    uint32_t maxUniformBufferRange;
-    uint32_t maxStorageBufferRange;
-    uint32_t maxPushConstantsSize;
-    uint32_t maxMemoryAllocationCount;
-    uint32_t maxSamplerAllocationCount;
-    VkDeviceSize DECLSPEC_ALIGN(8) bufferImageGranularity;
-    VkDeviceSize DECLSPEC_ALIGN(8) sparseAddressSpaceSize;
-    uint32_t maxBoundDescriptorSets;
-    uint32_t maxPerStageDescriptorSamplers;
-    uint32_t maxPerStageDescriptorUniformBuffers;
-    uint32_t maxPerStageDescriptorStorageBuffers;
-    uint32_t maxPerStageDescriptorSampledImages;
-    uint32_t maxPerStageDescriptorStorageImages;
-    uint32_t maxPerStageDescriptorInputAttachments;
-    uint32_t maxPerStageResources;
-    uint32_t maxDescriptorSetSamplers;
-    uint32_t maxDescriptorSetUniformBuffers;
-    uint32_t maxDescriptorSetUniformBuffersDynamic;
-    uint32_t maxDescriptorSetStorageBuffers;
-    uint32_t maxDescriptorSetStorageBuffersDynamic;
-    uint32_t maxDescriptorSetSampledImages;
-    uint32_t maxDescriptorSetStorageImages;
-    uint32_t maxDescriptorSetInputAttachments;
-    uint32_t maxVertexInputAttributes;
-    uint32_t maxVertexInputBindings;
-    uint32_t maxVertexInputAttributeOffset;
-    uint32_t maxVertexInputBindingStride;
-    uint32_t maxVertexOutputComponents;
-    uint32_t maxTessellationGenerationLevel;
-    uint32_t maxTessellationPatchSize;
-    uint32_t maxTessellationControlPerVertexInputComponents;
-    uint32_t maxTessellationControlPerVertexOutputComponents;
-    uint32_t maxTessellationControlPerPatchOutputComponents;
-    uint32_t maxTessellationControlTotalOutputComponents;
-    uint32_t maxTessellationEvaluationInputComponents;
-    uint32_t maxTessellationEvaluationOutputComponents;
-    uint32_t maxGeometryShaderInvocations;
-    uint32_t maxGeometryInputComponents;
-    uint32_t maxGeometryOutputComponents;
-    uint32_t maxGeometryOutputVertices;
-    uint32_t maxGeometryTotalOutputComponents;
-    uint32_t maxFragmentInputComponents;
-    uint32_t maxFragmentOutputAttachments;
-    uint32_t maxFragmentDualSrcAttachments;
-    uint32_t maxFragmentCombinedOutputResources;
-    uint32_t maxComputeSharedMemorySize;
-    uint32_t maxComputeWorkGroupCount[3];
-    uint32_t maxComputeWorkGroupInvocations;
-    uint32_t maxComputeWorkGroupSize[3];
-    uint32_t subPixelPrecisionBits;
-    uint32_t subTexelPrecisionBits;
-    uint32_t mipmapPrecisionBits;
-    uint32_t maxDrawIndexedIndexValue;
-    uint32_t maxDrawIndirectCount;
-    float maxSamplerLodBias;
-    float maxSamplerAnisotropy;
-    uint32_t maxViewports;
-    uint32_t maxViewportDimensions[2];
-    float viewportBoundsRange[2];
-    uint32_t viewportSubPixelBits;
-    PTR32 minMemoryMapAlignment;
-    VkDeviceSize DECLSPEC_ALIGN(8) minTexelBufferOffsetAlignment;
-    VkDeviceSize DECLSPEC_ALIGN(8) minUniformBufferOffsetAlignment;
-    VkDeviceSize DECLSPEC_ALIGN(8) minStorageBufferOffsetAlignment;
-    int32_t minTexelOffset;
-    uint32_t maxTexelOffset;
-    int32_t minTexelGatherOffset;
-    uint32_t maxTexelGatherOffset;
-    float minInterpolationOffset;
-    float maxInterpolationOffset;
-    uint32_t subPixelInterpolationOffsetBits;
-    uint32_t maxFramebufferWidth;
-    uint32_t maxFramebufferHeight;
-    uint32_t maxFramebufferLayers;
-    VkSampleCountFlags framebufferColorSampleCounts;
-    VkSampleCountFlags framebufferDepthSampleCounts;
-    VkSampleCountFlags framebufferStencilSampleCounts;
-    VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
-    uint32_t maxColorAttachments;
-    VkSampleCountFlags sampledImageColorSampleCounts;
-    VkSampleCountFlags sampledImageIntegerSampleCounts;
-    VkSampleCountFlags sampledImageDepthSampleCounts;
-    VkSampleCountFlags sampledImageStencilSampleCounts;
-    VkSampleCountFlags storageImageSampleCounts;
-    uint32_t maxSampleMaskWords;
-    VkBool32 timestampComputeAndGraphics;
-    float timestampPeriod;
-    uint32_t maxClipDistances;
-    uint32_t maxCullDistances;
-    uint32_t maxCombinedClipAndCullDistances;
-    uint32_t discreteQueuePriorities;
-    float pointSizeRange[2];
-    float lineWidthRange[2];
-    float pointSizeGranularity;
-    float lineWidthGranularity;
-    VkBool32 strictLines;
-    VkBool32 standardSampleLocations;
-    VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyOffsetAlignment;
-    VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyRowPitchAlignment;
-    VkDeviceSize DECLSPEC_ALIGN(8) nonCoherentAtomSize;
-} VkPhysicalDeviceLimits32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkProvokingVertexModeEXT provokingVertexMode;
+} VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32;

-typedef struct VkPhysicalDeviceProperties32
+typedef struct VkPipelineRasterizationStateRasterizationOrderAMD32
 {
-    uint32_t apiVersion;
-    uint32_t driverVersion;
-    uint32_t vendorID;
-    uint32_t deviceID;
-    VkPhysicalDeviceType deviceType;
-    char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
-    uint8_t pipelineCacheUUID[VK_UUID_SIZE];
-    VkPhysicalDeviceLimits32 DECLSPEC_ALIGN(8) limits;
-    VkPhysicalDeviceSparseProperties sparseProperties;
-} VkPhysicalDeviceProperties32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkRasterizationOrderAMD rasterizationOrder;
+} VkPipelineRasterizationStateRasterizationOrderAMD32;

-typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32
+typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxGraphicsShaderGroupCount;
-    uint32_t maxIndirectSequenceCount;
-    uint32_t maxIndirectCommandsTokenCount;
-    uint32_t maxIndirectCommandsStreamCount;
-    uint32_t maxIndirectCommandsTokenOffset;
-    uint32_t maxIndirectCommandsStreamStride;
-    uint32_t minSequencesCountBufferOffsetAlignment;
-    uint32_t minSequencesIndexBufferOffsetAlignment;
-    uint32_t minIndirectCommandsBufferOffsetAlignment;
-} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32;
+    VkPipelineRasterizationStateStreamCreateFlagsEXT flags;
+    uint32_t rasterizationStream;
+} VkPipelineRasterizationStateStreamCreateInfoEXT32;
+
+typedef struct VkPipelineRenderingCreateInfo32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t viewMask;
+    uint32_t colorAttachmentCount;
+    PTR32 pColorAttachmentFormats;
+    VkFormat depthAttachmentFormat;
+    VkFormat stencilAttachmentFormat;
+} VkPipelineRenderingCreateInfo32;
+typedef VkPipelineRenderingCreateInfo32 VkPipelineRenderingCreateInfoKHR32;

-typedef struct VkPhysicalDeviceClusterAccelerationStructurePropertiesNV32
+typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxVerticesPerCluster;
-    uint32_t maxTrianglesPerCluster;
-    uint32_t clusterScratchByteAlignment;
-    uint32_t clusterByteAlignment;
-    uint32_t clusterTemplateByteAlignment;
-    uint32_t clusterBottomLevelByteAlignment;
-    uint32_t clusterTemplateBoundsByteAlignment;
-    uint32_t maxClusterGeometryIndex;
-} VkPhysicalDeviceClusterAccelerationStructurePropertiesNV32;
+    VkBool32 representativeFragmentTestEnable;
+} VkPipelineRepresentativeFragmentTestStateCreateInfoNV32;

-typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT32
+typedef struct VkPipelineRobustnessCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxMultiDrawCount;
-} VkPhysicalDeviceMultiDrawPropertiesEXT32;
+    VkPipelineRobustnessBufferBehavior storageBuffers;
+    VkPipelineRobustnessBufferBehavior uniformBuffers;
+    VkPipelineRobustnessBufferBehavior vertexInputs;
+    VkPipelineRobustnessImageBehavior images;
+} VkPipelineRobustnessCreateInfo32;
+typedef VkPipelineRobustnessCreateInfo32 VkPipelineRobustnessCreateInfoEXT32;

-typedef struct VkPhysicalDevicePushDescriptorProperties32
+typedef struct VkPipelineSampleLocationsStateCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxPushDescriptors;
-} VkPhysicalDevicePushDescriptorProperties32;
-typedef VkPhysicalDevicePushDescriptorProperties32 VkPhysicalDevicePushDescriptorPropertiesKHR32;
+    VkBool32 sampleLocationsEnable;
+    VkSampleLocationsInfoEXT32 sampleLocationsInfo;
+} VkPipelineSampleLocationsStateCreateInfoEXT32;

-typedef struct VkPhysicalDeviceDriverProperties32
+typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDriverId driverID;
-    char driverName[VK_MAX_DRIVER_NAME_SIZE];
-    char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
-    VkConformanceVersion conformanceVersion;
-} VkPhysicalDeviceDriverProperties32;
-typedef VkPhysicalDeviceDriverProperties32 VkPhysicalDeviceDriverPropertiesKHR32;
+    uint32_t identifierSize;
+    PTR32 pIdentifier;
+} VkPipelineShaderStageModuleIdentifierCreateInfoEXT32;

-typedef struct VkPhysicalDeviceIDProperties32
+typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint8_t deviceUUID[VK_UUID_SIZE];
-    uint8_t driverUUID[VK_UUID_SIZE];
-    uint8_t deviceLUID[VK_LUID_SIZE];
-    uint32_t deviceNodeMask;
-    VkBool32 deviceLUIDValid;
-} VkPhysicalDeviceIDProperties32;
-typedef VkPhysicalDeviceIDProperties32 VkPhysicalDeviceIDPropertiesKHR32;
+    uint32_t requiredSubgroupSize;
+} VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32;
+typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT32;
+typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkShaderRequiredSubgroupSizeCreateInfoEXT32;

-typedef struct VkPhysicalDeviceMultiviewProperties32
+typedef struct VkPipelineTessellationDomainOriginStateCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxMultiviewViewCount;
-    uint32_t maxMultiviewInstanceIndex;
-} VkPhysicalDeviceMultiviewProperties32;
-typedef VkPhysicalDeviceMultiviewProperties32 VkPhysicalDeviceMultiviewPropertiesKHR32;
+    VkTessellationDomainOrigin domainOrigin;
+} VkPipelineTessellationDomainOriginStateCreateInfo32;
+typedef VkPipelineTessellationDomainOriginStateCreateInfo32 VkPipelineTessellationDomainOriginStateCreateInfoKHR32;

-typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT32
+typedef struct VkPipelineVertexInputDivisorStateCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxDiscardRectangles;
-} VkPhysicalDeviceDiscardRectanglePropertiesEXT32;
+    uint32_t vertexBindingDivisorCount;
+    PTR32 pVertexBindingDivisors;
+} VkPipelineVertexInputDivisorStateCreateInfo32;
+typedef VkPipelineVertexInputDivisorStateCreateInfo32 VkPipelineVertexInputDivisorStateCreateInfoKHR32;
+typedef VkPipelineVertexInputDivisorStateCreateInfo32 VkPipelineVertexInputDivisorStateCreateInfoEXT32;

-typedef struct VkPhysicalDeviceSubgroupProperties32
+typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t subgroupSize;
-    VkShaderStageFlags supportedStages;
-    VkSubgroupFeatureFlags supportedOperations;
-    VkBool32 quadOperationsInAllStages;
-} VkPhysicalDeviceSubgroupProperties32;
+    VkCoarseSampleOrderTypeNV sampleOrderType;
+    uint32_t customSampleOrderCount;
+    PTR32 pCustomSampleOrders;
+} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32;

-typedef struct VkPhysicalDevicePointClippingProperties32
+typedef struct VkPipelineViewportDepthClampControlCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPointClippingBehavior pointClippingBehavior;
-} VkPhysicalDevicePointClippingProperties32;
-typedef VkPhysicalDevicePointClippingProperties32 VkPhysicalDevicePointClippingPropertiesKHR32;
+    VkDepthClampModeEXT depthClampMode;
+    PTR32 pDepthClampRange;
+} VkPipelineViewportDepthClampControlCreateInfoEXT32;

-typedef struct VkPhysicalDeviceProtectedMemoryProperties32
+typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 protectedNoFault;
-} VkPhysicalDeviceProtectedMemoryProperties32;
+    VkBool32 negativeOneToOne;
+} VkPipelineViewportDepthClipControlCreateInfoEXT32;

-typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties32
+typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 filterMinmaxSingleComponentFormats;
-    VkBool32 filterMinmaxImageComponentMapping;
-} VkPhysicalDeviceSamplerFilterMinmaxProperties32;
-typedef VkPhysicalDeviceSamplerFilterMinmaxProperties32 VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT32;
+    uint32_t exclusiveScissorCount;
+    PTR32 pExclusiveScissors;
+} VkPipelineViewportExclusiveScissorStateCreateInfoNV32;

-typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT32
+typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSampleCountFlags sampleLocationSampleCounts;
-    VkExtent2D maxSampleLocationGridSize;
-    float sampleLocationCoordinateRange[2];
-    uint32_t sampleLocationSubPixelBits;
-    VkBool32 variableSampleLocations;
-} VkPhysicalDeviceSampleLocationsPropertiesEXT32;
+    VkBool32 shadingRateImageEnable;
+    uint32_t viewportCount;
+    PTR32 pShadingRatePalettes;
+} VkPipelineViewportShadingRateImageStateCreateInfoNV32;

-typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32
+typedef struct VkPipelineViewportSwizzleStateCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t advancedBlendMaxColorAttachments;
-    VkBool32 advancedBlendIndependentBlend;
-    VkBool32 advancedBlendNonPremultipliedSrcColor;
-    VkBool32 advancedBlendNonPremultipliedDstColor;
-    VkBool32 advancedBlendCorrelatedOverlap;
-    VkBool32 advancedBlendAllOperations;
-} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32;
+    VkPipelineViewportSwizzleStateCreateFlagsNV flags;
+    uint32_t viewportCount;
+    PTR32 pViewportSwizzles;
+} VkPipelineViewportSwizzleStateCreateInfoNV32;

-typedef struct VkPhysicalDeviceInlineUniformBlockProperties32
+typedef struct VkPipelineViewportWScalingStateCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxInlineUniformBlockSize;
-    uint32_t maxPerStageDescriptorInlineUniformBlocks;
-    uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
-    uint32_t maxDescriptorSetInlineUniformBlocks;
-    uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
-} VkPhysicalDeviceInlineUniformBlockProperties32;
-typedef VkPhysicalDeviceInlineUniformBlockProperties32 VkPhysicalDeviceInlineUniformBlockPropertiesEXT32;
+    VkBool32 viewportWScalingEnable;
+    uint32_t viewportCount;
+    PTR32 pViewportWScalings;
+} VkPipelineViewportWScalingStateCreateInfoNV32;

-typedef struct VkPhysicalDeviceMaintenance3Properties32
+typedef struct VkPresentId2KHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxPerSetDescriptors;
-    VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
-} VkPhysicalDeviceMaintenance3Properties32;
-typedef VkPhysicalDeviceMaintenance3Properties32 VkPhysicalDeviceMaintenance3PropertiesKHR32;
+    uint32_t swapchainCount;
+    PTR32 pPresentIds;
+} VkPresentId2KHR32;

-typedef struct VkPhysicalDeviceMaintenance4Properties32
+typedef struct VkPresentIdKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
-} VkPhysicalDeviceMaintenance4Properties32;
-typedef VkPhysicalDeviceMaintenance4Properties32 VkPhysicalDeviceMaintenance4PropertiesKHR32;
+    uint32_t swapchainCount;
+    PTR32 pPresentIds;
+} VkPresentIdKHR32;

-typedef struct VkPhysicalDeviceMaintenance5Properties32
+typedef struct VkPresentInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting;
-    VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting;
-    VkBool32 depthStencilSwizzleOneSupport;
-    VkBool32 polygonModePointSize;
-    VkBool32 nonStrictSinglePixelWideLinesUseParallelogram;
-    VkBool32 nonStrictWideLinesUseParallelogram;
-} VkPhysicalDeviceMaintenance5Properties32;
-typedef VkPhysicalDeviceMaintenance5Properties32 VkPhysicalDeviceMaintenance5PropertiesKHR32;
+    uint32_t waitSemaphoreCount;
+    PTR32 pWaitSemaphores;
+    uint32_t swapchainCount;
+    PTR32 pSwapchains;
+    PTR32 pImageIndices;
+    PTR32 pResults;
+} VkPresentInfoKHR32;

-typedef struct VkPhysicalDeviceMaintenance6Properties32
+typedef struct VkPresentRegionsKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 blockTexelViewCompatibleMultipleLayers;
-    uint32_t maxCombinedImageSamplerDescriptorCount;
-    VkBool32 fragmentShadingRateClampCombinerInputs;
-} VkPhysicalDeviceMaintenance6Properties32;
-typedef VkPhysicalDeviceMaintenance6Properties32 VkPhysicalDeviceMaintenance6PropertiesKHR32;
+    uint32_t swapchainCount;
+    PTR32 pRegions;
+} VkPresentRegionsKHR32;

-typedef struct VkPhysicalDeviceMaintenance9PropertiesKHR32
+typedef struct VkPresentWait2InfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 image2DViewOf3DSparse;
-    VkDefaultVertexAttributeValueKHR defaultVertexAttributeValue;
-} VkPhysicalDeviceMaintenance9PropertiesKHR32;
+    uint64_t DECLSPEC_ALIGN(8) presentId;
+    uint64_t DECLSPEC_ALIGN(8) timeout;
+} VkPresentWait2InfoKHR32;

-typedef struct VkPhysicalDeviceFloatControlsProperties32
+typedef struct VkPrivateDataSlotCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderFloatControlsIndependence denormBehaviorIndependence;
-    VkShaderFloatControlsIndependence roundingModeIndependence;
-    VkBool32 shaderSignedZeroInfNanPreserveFloat16;
-    VkBool32 shaderSignedZeroInfNanPreserveFloat32;
-    VkBool32 shaderSignedZeroInfNanPreserveFloat64;
-    VkBool32 shaderDenormPreserveFloat16;
-    VkBool32 shaderDenormPreserveFloat32;
-    VkBool32 shaderDenormPreserveFloat64;
-    VkBool32 shaderDenormFlushToZeroFloat16;
-    VkBool32 shaderDenormFlushToZeroFloat32;
-    VkBool32 shaderDenormFlushToZeroFloat64;
-    VkBool32 shaderRoundingModeRTEFloat16;
-    VkBool32 shaderRoundingModeRTEFloat32;
-    VkBool32 shaderRoundingModeRTEFloat64;
-    VkBool32 shaderRoundingModeRTZFloat16;
-    VkBool32 shaderRoundingModeRTZFloat32;
-    VkBool32 shaderRoundingModeRTZFloat64;
-} VkPhysicalDeviceFloatControlsProperties32;
-typedef VkPhysicalDeviceFloatControlsProperties32 VkPhysicalDeviceFloatControlsPropertiesKHR32;
+    VkPrivateDataSlotCreateFlags flags;
+} VkPrivateDataSlotCreateInfo32;
+typedef VkPrivateDataSlotCreateInfo32 VkPrivateDataSlotCreateInfoEXT32;

-typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT32
+typedef struct VkProtectedSubmitInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) minImportedHostPointerAlignment;
-} VkPhysicalDeviceExternalMemoryHostPropertiesEXT32;
+    VkBool32 protectedSubmit;
+} VkProtectedSubmitInfo32;

-typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT32
+typedef struct VkPushConstantsInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    float primitiveOverestimationSize;
-    float maxExtraPrimitiveOverestimationSize;
-    float extraPrimitiveOverestimationSizeGranularity;
-    VkBool32 primitiveUnderestimation;
-    VkBool32 conservativePointAndLineRasterization;
-    VkBool32 degenerateTrianglesRasterized;
-    VkBool32 degenerateLinesRasterized;
-    VkBool32 fullyCoveredFragmentShaderInputVariable;
-    VkBool32 conservativeRasterizationPostDepthCoverage;
-} VkPhysicalDeviceConservativeRasterizationPropertiesEXT32;
+    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
+    VkShaderStageFlags stageFlags;
+    uint32_t offset;
+    uint32_t size;
+    PTR32 pValues;
+} VkPushConstantsInfo32;
+typedef VkPushConstantsInfo32 VkPushConstantsInfoKHR32;

-typedef struct VkPhysicalDeviceShaderCorePropertiesAMD32
+typedef struct VkPushDescriptorSetInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t shaderEngineCount;
-    uint32_t shaderArraysPerEngineCount;
-    uint32_t computeUnitsPerShaderArray;
-    uint32_t simdPerComputeUnit;
-    uint32_t wavefrontsPerSimd;
-    uint32_t wavefrontSize;
-    uint32_t sgprsPerSimd;
-    uint32_t minSgprAllocation;
-    uint32_t maxSgprAllocation;
-    uint32_t sgprAllocationGranularity;
-    uint32_t vgprsPerSimd;
-    uint32_t minVgprAllocation;
-    uint32_t maxVgprAllocation;
-    uint32_t vgprAllocationGranularity;
-} VkPhysicalDeviceShaderCorePropertiesAMD32;
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
+    uint32_t set;
+    uint32_t descriptorWriteCount;
+    PTR32 pDescriptorWrites;
+} VkPushDescriptorSetInfo32;
+typedef VkPushDescriptorSetInfo32 VkPushDescriptorSetInfoKHR32;

-typedef struct VkPhysicalDeviceShaderCoreProperties2AMD32
+typedef struct VkPushDescriptorSetWithTemplateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
-    uint32_t activeComputeUnitCount;
-} VkPhysicalDeviceShaderCoreProperties2AMD32;
+    VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
+    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
+    uint32_t set;
+    PTR32 pData;
+} VkPushDescriptorSetWithTemplateInfo32;
+typedef VkPushDescriptorSetWithTemplateInfo32 VkPushDescriptorSetWithTemplateInfoKHR32;

-typedef struct VkPhysicalDeviceDescriptorIndexingProperties32
+typedef struct VkQueryLowLatencySupportNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxUpdateAfterBindDescriptorsInAllPools;
-    VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
-    VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
-    VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
-    VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
-    VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
-    VkBool32 robustBufferAccessUpdateAfterBind;
-    VkBool32 quadDivergentImplicitLod;
-    uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
-    uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
-    uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
-    uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
-    uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
-    uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
-    uint32_t maxPerStageUpdateAfterBindResources;
-    uint32_t maxDescriptorSetUpdateAfterBindSamplers;
-    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
-    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
-    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
-    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
-    uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
-    uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
-    uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
-} VkPhysicalDeviceDescriptorIndexingProperties32;
-typedef VkPhysicalDeviceDescriptorIndexingProperties32 VkPhysicalDeviceDescriptorIndexingPropertiesEXT32;
+    PTR32 pQueriedLowLatencyData;
+} VkQueryLowLatencySupportNV32;

-typedef struct VkPhysicalDeviceTimelineSemaphoreProperties32
+typedef struct VkQueryPoolCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
-} VkPhysicalDeviceTimelineSemaphoreProperties32;
-typedef VkPhysicalDeviceTimelineSemaphoreProperties32 VkPhysicalDeviceTimelineSemaphorePropertiesKHR32;
+    VkQueryPoolCreateFlags flags;
+    VkQueryType queryType;
+    uint32_t queryCount;
+    VkQueryPipelineStatisticFlags pipelineStatistics;
+} VkQueryPoolCreateInfo32;

-typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32
+typedef struct VkQueryPoolPerformanceCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxVertexAttribDivisor;
-} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32;
+    uint32_t queueFamilyIndex;
+    uint32_t counterIndexCount;
+    PTR32 pCounterIndices;
+} VkQueryPoolPerformanceCreateInfoKHR32;

-typedef struct VkPhysicalDeviceVertexAttributeDivisorProperties32
+typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxVertexAttribDivisor;
-    VkBool32 supportsNonZeroFirstInstance;
-} VkPhysicalDeviceVertexAttributeDivisorProperties32;
-typedef VkPhysicalDeviceVertexAttributeDivisorProperties32 VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR32;
+    VkQueryPoolSamplingModeINTEL performanceCountersSampling;
+} VkQueryPoolPerformanceQueryCreateInfoINTEL32;
+typedef VkQueryPoolPerformanceQueryCreateInfoINTEL32 VkQueryPoolCreateInfoINTEL32;

-typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT32
+typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t pciDomain;
-    uint32_t pciBus;
-    uint32_t pciDevice;
-    uint32_t pciFunction;
-} VkPhysicalDevicePCIBusInfoPropertiesEXT32;
+    VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags;
+} VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32;

-typedef struct VkPhysicalDeviceDepthStencilResolveProperties32
+typedef struct VkQueueFamilyCheckpointProperties2NV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkResolveModeFlags supportedDepthResolveModes;
-    VkResolveModeFlags supportedStencilResolveModes;
-    VkBool32 independentResolveNone;
-    VkBool32 independentResolve;
-} VkPhysicalDeviceDepthStencilResolveProperties32;
-typedef VkPhysicalDeviceDepthStencilResolveProperties32 VkPhysicalDeviceDepthStencilResolvePropertiesKHR32;
+    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) checkpointExecutionStageMask;
+} VkQueueFamilyCheckpointProperties2NV32;

-typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT32
+typedef struct VkQueueFamilyCheckpointPropertiesNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxTransformFeedbackStreams;
-    uint32_t maxTransformFeedbackBuffers;
-    VkDeviceSize DECLSPEC_ALIGN(8) maxTransformFeedbackBufferSize;
-    uint32_t maxTransformFeedbackStreamDataSize;
-    uint32_t maxTransformFeedbackBufferDataSize;
-    uint32_t maxTransformFeedbackBufferDataStride;
-    VkBool32 transformFeedbackQueries;
-    VkBool32 transformFeedbackStreamsLinesTriangles;
-    VkBool32 transformFeedbackRasterizationStreamSelect;
-    VkBool32 transformFeedbackDraw;
-} VkPhysicalDeviceTransformFeedbackPropertiesEXT32;
+    VkPipelineStageFlags checkpointExecutionStageMask;
+} VkQueueFamilyCheckpointPropertiesNV32;

-typedef struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32
+typedef struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 meshAndTaskShaderDerivatives;
-} VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32;
+    VkExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes;
+    VkExternalMemoryHandleTypeFlags foreignMemoryHandleTypes;
+} VkQueueFamilyDataGraphProcessingEnginePropertiesARM32;

-typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32
+typedef struct VkQueueFamilyDataGraphPropertiesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkQueueFlags supportedQueues;
-} VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32;
+    VkPhysicalDeviceDataGraphProcessingEngineARM engine;
+    VkPhysicalDeviceDataGraphOperationSupportARM operation;
+} VkQueueFamilyDataGraphPropertiesARM32;

-typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV32
+typedef struct VkQueueFamilyGlobalPriorityProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethods;
-    uint64_t DECLSPEC_ALIGN(8) maxDecompressionIndirectCount;
-} VkPhysicalDeviceMemoryDecompressionPropertiesNV32;
+    uint32_t priorityCount;
+    VkQueueGlobalPriority priorities[VK_MAX_GLOBAL_PRIORITY_SIZE];
+} VkQueueFamilyGlobalPriorityProperties32;
+typedef VkQueueFamilyGlobalPriorityProperties32 VkQueueFamilyGlobalPriorityPropertiesKHR32;
+typedef VkQueueFamilyGlobalPriorityProperties32 VkQueueFamilyGlobalPriorityPropertiesEXT32;

-typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV32
+typedef struct VkQueueFamilyOwnershipTransferPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExtent2D shadingRateTexelSize;
-    uint32_t shadingRatePaletteSize;
-    uint32_t shadingRateMaxCoarseSamples;
-} VkPhysicalDeviceShadingRateImagePropertiesNV32;
+    uint32_t optimalImageTransferToQueueFamilies;
+} VkQueueFamilyOwnershipTransferPropertiesKHR32;

-typedef struct VkPhysicalDeviceMeshShaderPropertiesNV32
+typedef struct VkQueueFamilyProperties232
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxDrawMeshTasksCount;
-    uint32_t maxTaskWorkGroupInvocations;
-    uint32_t maxTaskWorkGroupSize[3];
-    uint32_t maxTaskTotalMemorySize;
-    uint32_t maxTaskOutputCount;
-    uint32_t maxMeshWorkGroupInvocations;
-    uint32_t maxMeshWorkGroupSize[3];
-    uint32_t maxMeshTotalMemorySize;
-    uint32_t maxMeshOutputVertices;
-    uint32_t maxMeshOutputPrimitives;
-    uint32_t maxMeshMultiviewViewCount;
-    uint32_t meshOutputPerVertexGranularity;
-    uint32_t meshOutputPerPrimitiveGranularity;
-} VkPhysicalDeviceMeshShaderPropertiesNV32;
+    VkQueueFamilyProperties queueFamilyProperties;
+} VkQueueFamilyProperties232;
+typedef VkQueueFamilyProperties232 VkQueueFamilyProperties2KHR32;

-typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT32
+typedef struct VkQueueFamilyQueryResultStatusPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxTaskWorkGroupTotalCount;
-    uint32_t maxTaskWorkGroupCount[3];
-    uint32_t maxTaskWorkGroupInvocations;
-    uint32_t maxTaskWorkGroupSize[3];
-    uint32_t maxTaskPayloadSize;
-    uint32_t maxTaskSharedMemorySize;
-    uint32_t maxTaskPayloadAndSharedMemorySize;
-    uint32_t maxMeshWorkGroupTotalCount;
-    uint32_t maxMeshWorkGroupCount[3];
-    uint32_t maxMeshWorkGroupInvocations;
-    uint32_t maxMeshWorkGroupSize[3];
-    uint32_t maxMeshSharedMemorySize;
-    uint32_t maxMeshPayloadAndSharedMemorySize;
-    uint32_t maxMeshOutputMemorySize;
-    uint32_t maxMeshPayloadAndOutputMemorySize;
-    uint32_t maxMeshOutputComponents;
-    uint32_t maxMeshOutputVertices;
-    uint32_t maxMeshOutputPrimitives;
-    uint32_t maxMeshOutputLayers;
-    uint32_t maxMeshMultiviewViewCount;
-    uint32_t meshOutputPerVertexGranularity;
-    uint32_t meshOutputPerPrimitiveGranularity;
-    uint32_t maxPreferredTaskWorkGroupInvocations;
-    uint32_t maxPreferredMeshWorkGroupInvocations;
-    VkBool32 prefersLocalInvocationVertexOutput;
-    VkBool32 prefersLocalInvocationPrimitiveOutput;
-    VkBool32 prefersCompactVertexOutput;
-    VkBool32 prefersCompactPrimitiveOutput;
-} VkPhysicalDeviceMeshShaderPropertiesEXT32;
+    VkBool32 queryResultStatusSupport;
+} VkQueueFamilyQueryResultStatusPropertiesKHR32;

-typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR32
+typedef struct VkQueueFamilyVideoPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
-    uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
-    uint64_t DECLSPEC_ALIGN(8) maxPrimitiveCount;
-    uint32_t maxPerStageDescriptorAccelerationStructures;
-    uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
-    uint32_t maxDescriptorSetAccelerationStructures;
-    uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures;
-    uint32_t minAccelerationStructureScratchOffsetAlignment;
-} VkPhysicalDeviceAccelerationStructurePropertiesKHR32;
+    VkVideoCodecOperationFlagsKHR videoCodecOperations;
+} VkQueueFamilyVideoPropertiesKHR32;

-typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR32
+typedef struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t shaderGroupHandleSize;
-    uint32_t maxRayRecursionDepth;
-    uint32_t maxShaderGroupStride;
-    uint32_t shaderGroupBaseAlignment;
-    uint32_t shaderGroupHandleCaptureReplaySize;
-    uint32_t maxRayDispatchInvocationCount;
-    uint32_t shaderGroupHandleAlignment;
-    uint32_t maxRayHitAttributeSize;
-} VkPhysicalDeviceRayTracingPipelinePropertiesKHR32;
+    VkBool32 allowClusterAccelerationStructure;
+} VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32;

-typedef struct VkPhysicalDeviceRayTracingPropertiesNV32
+typedef struct VkRayTracingPipelineCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t shaderGroupHandleSize;
-    uint32_t maxRecursionDepth;
-    uint32_t maxShaderGroupStride;
-    uint32_t shaderGroupBaseAlignment;
-    uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
-    uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
-    uint64_t DECLSPEC_ALIGN(8) maxTriangleCount;
-    uint32_t maxDescriptorSetAccelerationStructures;
-} VkPhysicalDeviceRayTracingPropertiesNV32;
+    VkPipelineCreateFlags flags;
+    uint32_t stageCount;
+    PTR32 pStages;
+    uint32_t groupCount;
+    PTR32 pGroups;
+    uint32_t maxPipelineRayRecursionDepth;
+    PTR32 pLibraryInfo;
+    PTR32 pLibraryInterface;
+    PTR32 pDynamicState;
+    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
+    VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
+    int32_t basePipelineIndex;
+} VkRayTracingPipelineCreateInfoKHR32;

-typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT32
+typedef struct VkRayTracingPipelineCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExtent2D minFragmentDensityTexelSize;
-    VkExtent2D maxFragmentDensityTexelSize;
-    VkBool32 fragmentDensityInvocations;
-} VkPhysicalDeviceFragmentDensityMapPropertiesEXT32;
+    VkPipelineCreateFlags flags;
+    uint32_t stageCount;
+    PTR32 pStages;
+    uint32_t groupCount;
+    PTR32 pGroups;
+    uint32_t maxRecursionDepth;
+    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
+    VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
+    int32_t basePipelineIndex;
+} VkRayTracingPipelineCreateInfoNV32;

-typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32
+typedef struct VkReleaseCapturedPipelineDataInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 subsampledLoads;
-    VkBool32 subsampledCoarseReconstructionEarlyAccess;
-    uint32_t maxSubsampledArrayLayers;
-    uint32_t maxDescriptorSetSubsampledSamplers;
-} VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32;
+    VkPipeline DECLSPEC_ALIGN(8) pipeline;
+} VkReleaseCapturedPipelineDataInfoKHR32;

-typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32
+typedef struct VkReleaseSwapchainImagesInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExtent2D fragmentDensityOffsetGranularity;
-} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32;
-typedef VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32 VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32;
+    VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
+    uint32_t imageIndexCount;
+    PTR32 pImageIndices;
+} VkReleaseSwapchainImagesInfoKHR32;
+typedef VkReleaseSwapchainImagesInfoKHR32 VkReleaseSwapchainImagesInfoEXT32;

-typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV32
+typedef struct VkRenderPassAttachmentBeginInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderStageFlags cooperativeMatrixSupportedStages;
-} VkPhysicalDeviceCooperativeMatrixPropertiesNV32;
+    uint32_t attachmentCount;
+    PTR32 pAttachments;
+} VkRenderPassAttachmentBeginInfo32;
+typedef VkRenderPassAttachmentBeginInfo32 VkRenderPassAttachmentBeginInfoKHR32;

-typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR32
+typedef struct VkRenderPassBeginInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 allowCommandBufferQueryCopies;
-} VkPhysicalDevicePerformanceQueryPropertiesKHR32;
+    VkRenderPass DECLSPEC_ALIGN(8) renderPass;
+    VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
+    VkRect2D renderArea;
+    uint32_t clearValueCount;
+    PTR32 pClearValues;
+} VkRenderPassBeginInfo32;

-typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32
+typedef struct VkRenderPassCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t shaderSMCount;
-    uint32_t shaderWarpsPerSM;
-} VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32;
+    VkRenderPassCreateFlags flags;
+    uint32_t attachmentCount;
+    PTR32 pAttachments;
+    uint32_t subpassCount;
+    PTR32 pSubpasses;
+    uint32_t dependencyCount;
+    PTR32 pDependencies;
+} VkRenderPassCreateInfo32;

-typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties32
+typedef struct VkRenderPassCreateInfo232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
-    VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
-    VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
-    VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
-} VkPhysicalDeviceTexelBufferAlignmentProperties32;
-typedef VkPhysicalDeviceTexelBufferAlignmentProperties32 VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT32;
+    VkRenderPassCreateFlags flags;
+    uint32_t attachmentCount;
+    PTR32 pAttachments;
+    uint32_t subpassCount;
+    PTR32 pSubpasses;
+    uint32_t dependencyCount;
+    PTR32 pDependencies;
+    uint32_t correlatedViewMaskCount;
+    PTR32 pCorrelatedViewMasks;
+} VkRenderPassCreateInfo232;
+typedef VkRenderPassCreateInfo232 VkRenderPassCreateInfo2KHR32;

-typedef struct VkPhysicalDeviceSubgroupSizeControlProperties32
+typedef struct VkRenderPassCreationControlEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t minSubgroupSize;
-    uint32_t maxSubgroupSize;
-    uint32_t maxComputeWorkgroupSubgroups;
-    VkShaderStageFlags requiredSubgroupSizeStages;
-} VkPhysicalDeviceSubgroupSizeControlProperties32;
-typedef VkPhysicalDeviceSubgroupSizeControlProperties32 VkPhysicalDeviceSubgroupSizeControlPropertiesEXT32;
+    VkBool32 disallowMerging;
+} VkRenderPassCreationControlEXT32;

-typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32
+typedef struct VkRenderPassCreationFeedbackCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxSubpassShadingWorkgroupSizeAspectRatio;
-} VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32;
+    PTR32 pRenderPassFeedback;
+} VkRenderPassCreationFeedbackCreateInfoEXT32;

-typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32
+typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxWorkGroupCount[3];
-    uint32_t maxWorkGroupSize[3];
-    uint32_t maxOutputClusterCount;
-    VkDeviceSize DECLSPEC_ALIGN(8) indirectBufferOffsetAlignment;
-} VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32;
+    VkAttachmentReference fragmentDensityMapAttachment;
+} VkRenderPassFragmentDensityMapCreateInfoEXT32;

-typedef struct VkPhysicalDeviceLineRasterizationProperties32
+typedef struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t lineSubPixelPrecisionBits;
-} VkPhysicalDeviceLineRasterizationProperties32;
-typedef VkPhysicalDeviceLineRasterizationProperties32 VkPhysicalDeviceLineRasterizationPropertiesKHR32;
-typedef VkPhysicalDeviceLineRasterizationProperties32 VkPhysicalDeviceLineRasterizationPropertiesEXT32;
+    uint32_t fragmentDensityOffsetCount;
+    PTR32 pFragmentDensityOffsets;
+} VkRenderPassFragmentDensityMapOffsetEndInfoEXT32;
+typedef VkRenderPassFragmentDensityMapOffsetEndInfoEXT32 VkSubpassFragmentDensityMapOffsetEndInfoQCOM32;

-typedef struct VkPhysicalDeviceVulkan11Properties32
+typedef struct VkRenderPassInputAttachmentAspectCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint8_t deviceUUID[VK_UUID_SIZE];
-    uint8_t driverUUID[VK_UUID_SIZE];
-    uint8_t deviceLUID[VK_LUID_SIZE];
-    uint32_t deviceNodeMask;
-    VkBool32 deviceLUIDValid;
-    uint32_t subgroupSize;
-    VkShaderStageFlags subgroupSupportedStages;
-    VkSubgroupFeatureFlags subgroupSupportedOperations;
-    VkBool32 subgroupQuadOperationsInAllStages;
-    VkPointClippingBehavior pointClippingBehavior;
-    uint32_t maxMultiviewViewCount;
-    uint32_t maxMultiviewInstanceIndex;
-    VkBool32 protectedNoFault;
-    uint32_t maxPerSetDescriptors;
-    VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
-} VkPhysicalDeviceVulkan11Properties32;
+    uint32_t aspectReferenceCount;
+    PTR32 pAspectReferences;
+} VkRenderPassInputAttachmentAspectCreateInfo32;
+typedef VkRenderPassInputAttachmentAspectCreateInfo32 VkRenderPassInputAttachmentAspectCreateInfoKHR32;

-typedef struct VkPhysicalDeviceVulkan12Properties32
+typedef struct VkRenderPassMultiviewCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDriverId driverID;
-    char driverName[VK_MAX_DRIVER_NAME_SIZE];
-    char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
-    VkConformanceVersion conformanceVersion;
-    VkShaderFloatControlsIndependence denormBehaviorIndependence;
-    VkShaderFloatControlsIndependence roundingModeIndependence;
-    VkBool32 shaderSignedZeroInfNanPreserveFloat16;
-    VkBool32 shaderSignedZeroInfNanPreserveFloat32;
-    VkBool32 shaderSignedZeroInfNanPreserveFloat64;
-    VkBool32 shaderDenormPreserveFloat16;
-    VkBool32 shaderDenormPreserveFloat32;
-    VkBool32 shaderDenormPreserveFloat64;
-    VkBool32 shaderDenormFlushToZeroFloat16;
-    VkBool32 shaderDenormFlushToZeroFloat32;
-    VkBool32 shaderDenormFlushToZeroFloat64;
-    VkBool32 shaderRoundingModeRTEFloat16;
-    VkBool32 shaderRoundingModeRTEFloat32;
-    VkBool32 shaderRoundingModeRTEFloat64;
-    VkBool32 shaderRoundingModeRTZFloat16;
-    VkBool32 shaderRoundingModeRTZFloat32;
-    VkBool32 shaderRoundingModeRTZFloat64;
-    uint32_t maxUpdateAfterBindDescriptorsInAllPools;
-    VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
-    VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
-    VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
-    VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
-    VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
-    VkBool32 robustBufferAccessUpdateAfterBind;
-    VkBool32 quadDivergentImplicitLod;
-    uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
-    uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
-    uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
-    uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
-    uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
-    uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
-    uint32_t maxPerStageUpdateAfterBindResources;
-    uint32_t maxDescriptorSetUpdateAfterBindSamplers;
-    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
-    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
-    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
-    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
-    uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
-    uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
-    uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
-    VkResolveModeFlags supportedDepthResolveModes;
-    VkResolveModeFlags supportedStencilResolveModes;
-    VkBool32 independentResolveNone;
-    VkBool32 independentResolve;
-    VkBool32 filterMinmaxSingleComponentFormats;
-    VkBool32 filterMinmaxImageComponentMapping;
-    uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
-    VkSampleCountFlags framebufferIntegerColorSampleCounts;
-} VkPhysicalDeviceVulkan12Properties32;
+    uint32_t subpassCount;
+    PTR32 pViewMasks;
+    uint32_t dependencyCount;
+    PTR32 pViewOffsets;
+    uint32_t correlationMaskCount;
+    PTR32 pCorrelationMasks;
+} VkRenderPassMultiviewCreateInfo32;
+typedef VkRenderPassMultiviewCreateInfo32 VkRenderPassMultiviewCreateInfoKHR32;

-typedef struct VkPhysicalDeviceVulkan13Properties32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    uint32_t minSubgroupSize;
-    uint32_t maxSubgroupSize;
-    uint32_t maxComputeWorkgroupSubgroups;
-    VkShaderStageFlags requiredSubgroupSizeStages;
-    uint32_t maxInlineUniformBlockSize;
-    uint32_t maxPerStageDescriptorInlineUniformBlocks;
-    uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
-    uint32_t maxDescriptorSetInlineUniformBlocks;
-    uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
-    uint32_t maxInlineUniformTotalSize;
-    VkBool32 integerDotProduct8BitUnsignedAccelerated;
-    VkBool32 integerDotProduct8BitSignedAccelerated;
-    VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
-    VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
-    VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
-    VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
-    VkBool32 integerDotProduct16BitUnsignedAccelerated;
-    VkBool32 integerDotProduct16BitSignedAccelerated;
-    VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
-    VkBool32 integerDotProduct32BitUnsignedAccelerated;
-    VkBool32 integerDotProduct32BitSignedAccelerated;
-    VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
-    VkBool32 integerDotProduct64BitUnsignedAccelerated;
-    VkBool32 integerDotProduct64BitSignedAccelerated;
-    VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
-    VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
-    VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
-    VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
-    VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
-    VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
-} VkPhysicalDeviceVulkan13Properties32;
+typedef struct VkRenderPassSampleLocationsBeginInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t attachmentInitialSampleLocationsCount;
+    PTR32 pAttachmentInitialSampleLocations;
+    uint32_t postSubpassSampleLocationsCount;
+    PTR32 pPostSubpassSampleLocations;
+} VkRenderPassSampleLocationsBeginInfoEXT32;

-typedef struct VkPhysicalDeviceVulkan14Properties32
+typedef struct VkRenderPassStripeBeginInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t lineSubPixelPrecisionBits;
-    uint32_t maxVertexAttribDivisor;
-    VkBool32 supportsNonZeroFirstInstance;
-    uint32_t maxPushDescriptors;
-    VkBool32 dynamicRenderingLocalReadDepthStencilAttachments;
-    VkBool32 dynamicRenderingLocalReadMultisampledAttachments;
-    VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting;
-    VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting;
-    VkBool32 depthStencilSwizzleOneSupport;
-    VkBool32 polygonModePointSize;
-    VkBool32 nonStrictSinglePixelWideLinesUseParallelogram;
-    VkBool32 nonStrictWideLinesUseParallelogram;
-    VkBool32 blockTexelViewCompatibleMultipleLayers;
-    uint32_t maxCombinedImageSamplerDescriptorCount;
-    VkBool32 fragmentShadingRateClampCombinerInputs;
-    VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers;
-    VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers;
-    VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs;
-    VkPipelineRobustnessImageBehavior defaultRobustnessImages;
-    uint32_t copySrcLayoutCount;
-    PTR32 pCopySrcLayouts;
-    uint32_t copyDstLayoutCount;
-    PTR32 pCopyDstLayouts;
-    uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE];
-    VkBool32 identicalMemoryTypeRequirements;
-} VkPhysicalDeviceVulkan14Properties32;
+    uint32_t stripeInfoCount;
+    PTR32 pStripeInfos;
+} VkRenderPassStripeBeginInfoARM32;

-typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT32
+typedef struct VkRenderPassStripeSubmitInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxCustomBorderColorSamplers;
-} VkPhysicalDeviceCustomBorderColorPropertiesEXT32;
+    uint32_t stripeSemaphoreInfoCount;
+    PTR32 pStripeSemaphoreInfos;
+} VkRenderPassStripeSubmitInfoARM32;

-typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32
+typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 dynamicPrimitiveTopologyUnrestricted;
-} VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32;
+    PTR32 pSubpassFeedback;
+} VkRenderPassSubpassFeedbackCreateInfoEXT32;

-typedef struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV32
+typedef struct VkRenderPassTileShadingCreateInfoQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxPartitionCount;
-} VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV32;
+    VkTileShadingRenderPassFlagsQCOM flags;
+    VkExtent2D tileApronSize;
+} VkRenderPassTileShadingCreateInfoQCOM32;

-typedef struct VkPhysicalDeviceRobustness2PropertiesKHR32
+typedef struct VkRenderPassTransformBeginInfoQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) robustStorageBufferAccessSizeAlignment;
-    VkDeviceSize DECLSPEC_ALIGN(8) robustUniformBufferAccessSizeAlignment;
-} VkPhysicalDeviceRobustness2PropertiesKHR32;
-typedef VkPhysicalDeviceRobustness2PropertiesKHR32 VkPhysicalDeviceRobustness2PropertiesEXT32;
+    VkSurfaceTransformFlagBitsKHR transform;
+} VkRenderPassTransformBeginInfoQCOM32;

-typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR32
+typedef struct VkRenderingAreaInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExtent2D minFragmentShadingRateAttachmentTexelSize;
-    VkExtent2D maxFragmentShadingRateAttachmentTexelSize;
-    uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
-    VkBool32 primitiveFragmentShadingRateWithMultipleViewports;
-    VkBool32 layeredShadingRateAttachments;
-    VkBool32 fragmentShadingRateNonTrivialCombinerOps;
-    VkExtent2D maxFragmentSize;
-    uint32_t maxFragmentSizeAspectRatio;
-    uint32_t maxFragmentShadingRateCoverageSamples;
-    VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples;
-    VkBool32 fragmentShadingRateWithShaderDepthStencilWrites;
-    VkBool32 fragmentShadingRateWithSampleMask;
-    VkBool32 fragmentShadingRateWithShaderSampleMask;
-    VkBool32 fragmentShadingRateWithConservativeRasterization;
-    VkBool32 fragmentShadingRateWithFragmentShaderInterlock;
-    VkBool32 fragmentShadingRateWithCustomSampleLocations;
-    VkBool32 fragmentShadingRateStrictMultiplyCombiner;
-} VkPhysicalDeviceFragmentShadingRatePropertiesKHR32;
+    uint32_t viewMask;
+    uint32_t colorAttachmentCount;
+    PTR32 pColorAttachmentFormats;
+    VkFormat depthAttachmentFormat;
+    VkFormat stencilAttachmentFormat;
+} VkRenderingAreaInfo32;
+typedef VkRenderingAreaInfo32 VkRenderingAreaInfoKHR32;

-typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32
+typedef struct VkRenderingAttachmentLocationInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSampleCountFlagBits maxFragmentShadingRateInvocationCount;
-} VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32;
+    uint32_t colorAttachmentCount;
+    PTR32 pColorAttachmentLocations;
+} VkRenderingAttachmentLocationInfo32;
+typedef VkRenderingAttachmentLocationInfo32 VkRenderingAttachmentLocationInfoKHR32;

-typedef struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32
+typedef struct VkRenderingEndInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 nativeUnalignedPerformance;
-} VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32;
+} VkRenderingEndInfoEXT32;

-typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32
+typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxIndirectPipelineCount;
-    uint32_t maxIndirectShaderObjectCount;
-    uint32_t maxIndirectSequenceCount;
-    uint32_t maxIndirectCommandsTokenCount;
-    uint32_t maxIndirectCommandsTokenOffset;
-    uint32_t maxIndirectCommandsIndirectStride;
-    VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes;
-    VkShaderStageFlags supportedIndirectCommandsShaderStages;
-    VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding;
-    VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding;
-    VkBool32 deviceGeneratedCommandsTransformFeedback;
-    VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount;
-} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32;
+    VkImageView DECLSPEC_ALIGN(8) imageView;
+    VkImageLayout imageLayout;
+} VkRenderingFragmentDensityMapAttachmentInfoEXT32;

-typedef struct VkPhysicalDeviceHostImageCopyProperties32
+typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t copySrcLayoutCount;
-    PTR32 pCopySrcLayouts;
-    uint32_t copyDstLayoutCount;
-    PTR32 pCopyDstLayouts;
-    uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE];
-    VkBool32 identicalMemoryTypeRequirements;
-} VkPhysicalDeviceHostImageCopyProperties32;
-typedef VkPhysicalDeviceHostImageCopyProperties32 VkPhysicalDeviceHostImageCopyPropertiesEXT32;
+    VkImageView DECLSPEC_ALIGN(8) imageView;
+    VkImageLayout imageLayout;
+    VkExtent2D shadingRateAttachmentTexelSize;
+} VkRenderingFragmentShadingRateAttachmentInfoKHR32;

-typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32
+typedef struct VkRenderingInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 provokingVertexModePerPipeline;
-    VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex;
-} VkPhysicalDeviceProvokingVertexPropertiesEXT32;
+    VkRenderingFlags flags;
+    VkRect2D renderArea;
+    uint32_t layerCount;
+    uint32_t viewMask;
+    uint32_t colorAttachmentCount;
+    PTR32 pColorAttachments;
+    PTR32 pDepthAttachment;
+    PTR32 pStencilAttachment;
+} VkRenderingInfo32;
+typedef VkRenderingInfo32 VkRenderingInfoKHR32;

-typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT32
+typedef struct VkRenderingInputAttachmentIndexInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 combinedImageSamplerDescriptorSingleArray;
-    VkBool32 bufferlessPushDescriptors;
-    VkBool32 allowSamplerImageViewPostSubmitCreation;
-    VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferOffsetAlignment;
-    uint32_t maxDescriptorBufferBindings;
-    uint32_t maxResourceDescriptorBufferBindings;
-    uint32_t maxSamplerDescriptorBufferBindings;
-    uint32_t maxEmbeddedImmutableSamplerBindings;
-    uint32_t maxEmbeddedImmutableSamplers;
-    PTR32 bufferCaptureReplayDescriptorDataSize;
-    PTR32 imageCaptureReplayDescriptorDataSize;
-    PTR32 imageViewCaptureReplayDescriptorDataSize;
-    PTR32 samplerCaptureReplayDescriptorDataSize;
-    PTR32 accelerationStructureCaptureReplayDescriptorDataSize;
-    PTR32 samplerDescriptorSize;
-    PTR32 combinedImageSamplerDescriptorSize;
-    PTR32 sampledImageDescriptorSize;
-    PTR32 storageImageDescriptorSize;
-    PTR32 uniformTexelBufferDescriptorSize;
-    PTR32 robustUniformTexelBufferDescriptorSize;
-    PTR32 storageTexelBufferDescriptorSize;
-    PTR32 robustStorageTexelBufferDescriptorSize;
-    PTR32 uniformBufferDescriptorSize;
-    PTR32 robustUniformBufferDescriptorSize;
-    PTR32 storageBufferDescriptorSize;
-    PTR32 robustStorageBufferDescriptorSize;
-    PTR32 inputAttachmentDescriptorSize;
-    PTR32 accelerationStructureDescriptorSize;
-    VkDeviceSize DECLSPEC_ALIGN(8) maxSamplerDescriptorBufferRange;
-    VkDeviceSize DECLSPEC_ALIGN(8) maxResourceDescriptorBufferRange;
-    VkDeviceSize DECLSPEC_ALIGN(8) samplerDescriptorBufferAddressSpaceSize;
-    VkDeviceSize DECLSPEC_ALIGN(8) resourceDescriptorBufferAddressSpaceSize;
-    VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferAddressSpaceSize;
-} VkPhysicalDeviceDescriptorBufferPropertiesEXT32;
+    uint32_t colorAttachmentCount;
+    PTR32 pColorAttachmentInputIndices;
+    PTR32 pDepthInputAttachmentIndex;
+    PTR32 pStencilInputAttachmentIndex;
+} VkRenderingInputAttachmentIndexInfo32;
+typedef VkRenderingInputAttachmentIndexInfo32 VkRenderingInputAttachmentIndexInfoKHR32;

-typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32
+typedef struct VkResolveImageInfo232
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkImage DECLSPEC_ALIGN(8) srcImage;
+    VkImageLayout srcImageLayout;
+    VkImage DECLSPEC_ALIGN(8) dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    PTR32 pRegions;
+} VkResolveImageInfo232;
+typedef VkResolveImageInfo232 VkResolveImageInfo2KHR32;
+
+typedef struct VkSamplerBlockMatchWindowCreateInfoQCOM32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkExtent2D windowExtent;
+    VkBlockMatchWindowCompareModeQCOM windowCompareMode;
+} VkSamplerBlockMatchWindowCreateInfoQCOM32;
+
+typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkComponentMapping components;
+    VkBool32 srgb;
+} VkSamplerBorderColorComponentMappingCreateInfoEXT32;
+
+typedef struct VkSamplerCaptureDescriptorDataInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkSampler DECLSPEC_ALIGN(8) sampler;
+} VkSamplerCaptureDescriptorDataInfoEXT32;
+
+typedef struct VkSamplerCreateInfo32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkSamplerCreateFlags flags;
+    VkFilter magFilter;
+    VkFilter minFilter;
+    VkSamplerMipmapMode mipmapMode;
+    VkSamplerAddressMode addressModeU;
+    VkSamplerAddressMode addressModeV;
+    VkSamplerAddressMode addressModeW;
+    float mipLodBias;
+    VkBool32 anisotropyEnable;
+    float maxAnisotropy;
+    VkBool32 compareEnable;
+    VkCompareOp compareOp;
+    float minLod;
+    float maxLod;
+    VkBorderColor borderColor;
+    VkBool32 unnormalizedCoordinates;
+} VkSamplerCreateInfo32;
+
+typedef struct VkSamplerCubicWeightsCreateInfoQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 combinedImageSamplerDensityMapDescriptorSize;
-} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32;
+    VkCubicFilterWeightsQCOM cubicWeights;
+} VkSamplerCubicWeightsCreateInfoQCOM32;

-typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties32
+typedef struct VkSamplerCustomBorderColorCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 integerDotProduct8BitUnsignedAccelerated;
-    VkBool32 integerDotProduct8BitSignedAccelerated;
-    VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
-    VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
-    VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
-    VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
-    VkBool32 integerDotProduct16BitUnsignedAccelerated;
-    VkBool32 integerDotProduct16BitSignedAccelerated;
-    VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
-    VkBool32 integerDotProduct32BitUnsignedAccelerated;
-    VkBool32 integerDotProduct32BitSignedAccelerated;
-    VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
-    VkBool32 integerDotProduct64BitUnsignedAccelerated;
-    VkBool32 integerDotProduct64BitSignedAccelerated;
-    VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
-    VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
-} VkPhysicalDeviceShaderIntegerDotProductProperties32;
-typedef VkPhysicalDeviceShaderIntegerDotProductProperties32 VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR32;
+    VkClearColorValue customBorderColor;
+    VkFormat format;
+} VkSamplerCustomBorderColorCreateInfoEXT32;

-typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32
+typedef struct VkSamplerReductionModeCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 triStripVertexOrderIndependentOfProvokingVertex;
-} VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32;
+    VkSamplerReductionMode reductionMode;
+} VkSamplerReductionModeCreateInfo32;
+typedef VkSamplerReductionModeCreateInfo32 VkSamplerReductionModeCreateInfoEXT32;

-typedef struct VkPhysicalDevicePipelineBinaryPropertiesKHR32
+typedef struct VkSamplerYcbcrConversionCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 pipelineBinaryInternalCache;
-    VkBool32 pipelineBinaryInternalCacheControl;
-    VkBool32 pipelineBinaryPrefersInternalCache;
-    VkBool32 pipelineBinaryPrecompiledInternalCache;
-    VkBool32 pipelineBinaryCompressedData;
-} VkPhysicalDevicePipelineBinaryPropertiesKHR32;
+    VkFormat format;
+    VkSamplerYcbcrModelConversion ycbcrModel;
+    VkSamplerYcbcrRange ycbcrRange;
+    VkComponentMapping components;
+    VkChromaLocation xChromaOffset;
+    VkChromaLocation yChromaOffset;
+    VkFilter chromaFilter;
+    VkBool32 forceExplicitReconstruction;
+} VkSamplerYcbcrConversionCreateInfo32;
+typedef VkSamplerYcbcrConversionCreateInfo32 VkSamplerYcbcrConversionCreateInfoKHR32;

-typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32
+typedef struct VkSamplerYcbcrConversionImageFormatProperties32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 graphicsPipelineLibraryFastLinking;
-    VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration;
-} VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32;
+    uint32_t combinedImageSamplerDescriptorCount;
+} VkSamplerYcbcrConversionImageFormatProperties32;
+typedef VkSamplerYcbcrConversionImageFormatProperties32 VkSamplerYcbcrConversionImageFormatPropertiesKHR32;

-typedef struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT32
+typedef struct VkSamplerYcbcrConversionInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxCommandBufferNestingLevel;
-} VkPhysicalDeviceNestedCommandBufferPropertiesEXT32;
+    VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) conversion;
+} VkSamplerYcbcrConversionInfo32;
+typedef VkSamplerYcbcrConversionInfo32 VkSamplerYcbcrConversionInfoKHR32;

-typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32
+typedef struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE];
-} VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32;
+    VkBool32 enableYDegamma;
+    VkBool32 enableCbCrDegamma;
+} VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM32;

-typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT32
+typedef struct VkSemaphoreCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxOpacity2StateSubdivisionLevel;
-    uint32_t maxOpacity4StateSubdivisionLevel;
-} VkPhysicalDeviceOpacityMicromapPropertiesEXT32;
+    VkSemaphoreCreateFlags flags;
+} VkSemaphoreCreateInfo32;

-typedef struct VkPhysicalDevicePipelineRobustnessProperties32
+typedef struct VkSemaphoreSignalInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers;
-    VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers;
-    VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs;
-    VkPipelineRobustnessImageBehavior defaultRobustnessImages;
-} VkPhysicalDevicePipelineRobustnessProperties32;
-typedef VkPhysicalDevicePipelineRobustnessProperties32 VkPhysicalDevicePipelineRobustnessPropertiesEXT32;
+    VkSemaphore DECLSPEC_ALIGN(8) semaphore;
+    uint64_t DECLSPEC_ALIGN(8) value;
+} VkSemaphoreSignalInfo32;
+typedef VkSemaphoreSignalInfo32 VkSemaphoreSignalInfoKHR32;

-typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM32
+typedef struct VkSemaphoreTypeCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxWeightFilterPhases;
-    VkExtent2D maxWeightFilterDimension;
-    VkExtent2D maxBlockMatchRegion;
-    VkExtent2D maxBoxFilterBlockSize;
-} VkPhysicalDeviceImageProcessingPropertiesQCOM32;
+    VkSemaphoreType semaphoreType;
+    uint64_t DECLSPEC_ALIGN(8) initialValue;
+} VkSemaphoreTypeCreateInfo32;
+typedef VkSemaphoreTypeCreateInfo32 VkSemaphoreTypeCreateInfoKHR32;

-typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV32
+typedef struct VkSemaphoreWaitInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes;
-    VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes;
-    VkBool32 hintSupported;
-    VkBool32 costSupported;
-    VkBool32 bidirectionalFlowSupported;
-    VkBool32 globalFlowSupported;
-    uint32_t minWidth;
-    uint32_t minHeight;
-    uint32_t maxWidth;
-    uint32_t maxHeight;
-    uint32_t maxNumRegionsOfInterest;
-} VkPhysicalDeviceOpticalFlowPropertiesNV32;
+    VkSemaphoreWaitFlags flags;
+    uint32_t semaphoreCount;
+    PTR32 pSemaphores;
+    PTR32 pValues;
+} VkSemaphoreWaitInfo32;
+typedef VkSemaphoreWaitInfo32 VkSemaphoreWaitInfoKHR32;

-typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32
+typedef struct VkSetDescriptorBufferOffsetsInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint64_t DECLSPEC_ALIGN(8) shaderCoreMask;
-    uint32_t shaderCoreCount;
-    uint32_t shaderWarpsPerCore;
-} VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32;
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout DECLSPEC_ALIGN(8) layout;
+    uint32_t firstSet;
+    uint32_t setCount;
+    PTR32 pBufferIndices;
+    PTR32 pOffsets;
+} VkSetDescriptorBufferOffsetsInfoEXT32;

-typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32
+typedef struct VkSetLatencyMarkerInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint;
-} VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32;
+    uint64_t DECLSPEC_ALIGN(8) presentID;
+    VkLatencyMarkerNV marker;
+} VkSetLatencyMarkerInfoNV32;

-typedef struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV32
+typedef struct VkShaderCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) extendedSparseAddressSpaceSize;
-    VkImageUsageFlags extendedSparseImageUsageFlags;
-    VkBufferUsageFlags extendedSparseBufferUsageFlags;
-} VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV32;
+    VkShaderCreateFlagsEXT flags;
+    VkShaderStageFlagBits stage;
+    VkShaderStageFlags nextStage;
+    VkShaderCodeTypeEXT codeType;
+    PTR32 codeSize;
+    PTR32 pCode;
+    PTR32 pName;
+    uint32_t setLayoutCount;
+    PTR32 pSetLayouts;
+    uint32_t pushConstantRangeCount;
+    PTR32 pPushConstantRanges;
+    PTR32 pSpecializationInfo;
+} VkShaderCreateInfoEXT32;

-typedef struct VkPhysicalDeviceShaderCorePropertiesARM32
+typedef struct VkShaderModuleCreateInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t pixelRate;
-    uint32_t texelRate;
-    uint32_t fmaRate;
-} VkPhysicalDeviceShaderCorePropertiesARM32;
+    VkShaderModuleCreateFlags flags;
+    PTR32 codeSize;
+    PTR32 pCode;
+} VkShaderModuleCreateInfo32;

-typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT32
+typedef struct VkShaderModuleIdentifierEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint8_t shaderBinaryUUID[VK_UUID_SIZE];
-    uint32_t shaderBinaryVersion;
-} VkPhysicalDeviceShaderObjectPropertiesEXT32;
+    uint32_t identifierSize;
+    uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT];
+} VkShaderModuleIdentifierEXT32;

-typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT32
+typedef struct VkShaderModuleValidationCacheCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 shaderTileImageCoherentReadAccelerated;
-    VkBool32 shaderTileImageReadSampleFromPixelRateInvocation;
-    VkBool32 shaderTileImageReadFromHelperInvocation;
-} VkPhysicalDeviceShaderTileImagePropertiesEXT32;
+    VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
+} VkShaderModuleValidationCacheCreateInfoEXT32;

-typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR32
+typedef struct VkSparseImageFormatProperties232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderStageFlags cooperativeMatrixSupportedStages;
-} VkPhysicalDeviceCooperativeMatrixPropertiesKHR32;
+    VkSparseImageFormatProperties properties;
+} VkSparseImageFormatProperties232;
+typedef VkSparseImageFormatProperties232 VkSparseImageFormatProperties2KHR32;

-typedef struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32
+typedef struct VkSparseImageMemoryRequirements232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 queueSubmitBoundary;
-    VkBool32 tileBufferTransfers;
-} VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32;
+    VkSparseImageMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
+} VkSparseImageMemoryRequirements232;
+typedef VkSparseImageMemoryRequirements232 VkSparseImageMemoryRequirements2KHR32;

-typedef struct VkPhysicalDeviceImageProcessing2PropertiesQCOM32
+typedef struct VkSubmitInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExtent2D maxBlockMatchWindow;
-} VkPhysicalDeviceImageProcessing2PropertiesQCOM32;
+    uint32_t waitSemaphoreCount;
+    PTR32 pWaitSemaphores;
+    PTR32 pWaitDstStageMask;
+    uint32_t commandBufferCount;
+    PTR32 pCommandBuffers;
+    uint32_t signalSemaphoreCount;
+    PTR32 pSignalSemaphores;
+} VkSubmitInfo32;

-typedef struct VkPhysicalDeviceLayeredDriverPropertiesMSFT32
+typedef struct VkSubmitInfo232
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkLayeredDriverUnderlyingApiMSFT underlyingAPI;
-} VkPhysicalDeviceLayeredDriverPropertiesMSFT32;
+    VkSubmitFlags flags;
+    uint32_t waitSemaphoreInfoCount;
+    PTR32 pWaitSemaphoreInfos;
+    uint32_t commandBufferInfoCount;
+    PTR32 pCommandBufferInfos;
+    uint32_t signalSemaphoreInfoCount;
+    PTR32 pSignalSemaphoreInfos;
+} VkSubmitInfo232;
+typedef VkSubmitInfo232 VkSubmitInfo2KHR32;

-typedef struct VkPhysicalDeviceSchedulingControlsPropertiesARM32
+typedef struct VkSubpassBeginInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPhysicalDeviceSchedulingControlsFlagsARM DECLSPEC_ALIGN(8) schedulingControlsFlags;
-} VkPhysicalDeviceSchedulingControlsPropertiesARM32;
+    VkSubpassContents contents;
+} VkSubpassBeginInfo32;
+typedef VkSubpassBeginInfo32 VkSubpassBeginInfoKHR32;

-typedef struct VkPhysicalDeviceRenderPassStripedPropertiesARM32
+typedef struct VkSubpassDescriptionDepthStencilResolve32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExtent2D renderPassStripeGranularity;
-    uint32_t maxRenderPassStripes;
-} VkPhysicalDeviceRenderPassStripedPropertiesARM32;
+    VkResolveModeFlagBits depthResolveMode;
+    VkResolveModeFlagBits stencilResolveMode;
+    PTR32 pDepthStencilResolveAttachment;
+} VkSubpassDescriptionDepthStencilResolve32;
+typedef VkSubpassDescriptionDepthStencilResolve32 VkSubpassDescriptionDepthStencilResolveKHR32;

-typedef struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32
+typedef struct VkSubpassEndInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) minPlacedMemoryMapAlignment;
-} VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32;
+} VkSubpassEndInfo32;
+typedef VkSubpassEndInfo32 VkSubpassEndInfoKHR32;

-typedef struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA32
+typedef struct VkSubpassResolvePerformanceQueryEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t supportedImageAlignmentMask;
-} VkPhysicalDeviceImageAlignmentControlPropertiesMESA32;
+    VkBool32 optimal;
+} VkSubpassResolvePerformanceQueryEXT32;

-typedef struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV32
+typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize;
-    uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension;
-    uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory;
-} VkPhysicalDeviceCooperativeMatrix2PropertiesNV32;
+    VkRenderPass DECLSPEC_ALIGN(8) renderPass;
+    uint32_t subpass;
+} VkSubpassShadingPipelineCreateInfoHUAWEI32;

-typedef struct VkPhysicalDeviceCooperativeVectorPropertiesNV32
+typedef struct VkSubresourceHostMemcpySize32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderStageFlags cooperativeVectorSupportedStages;
-    VkBool32 cooperativeVectorTrainingFloat16Accumulation;
-    VkBool32 cooperativeVectorTrainingFloat32Accumulation;
-    uint32_t maxCooperativeVectorComponents;
-} VkPhysicalDeviceCooperativeVectorPropertiesNV32;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+} VkSubresourceHostMemcpySize32;
+typedef VkSubresourceHostMemcpySize32 VkSubresourceHostMemcpySizeEXT32;

-typedef struct VkPhysicalDeviceTileShadingPropertiesQCOM32
+typedef struct VkSubresourceLayout232
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxApronSize;
-    VkBool32 preferNonCoherent;
-    VkExtent2D tileGranularity;
-    VkExtent2D maxTileShadingRate;
-} VkPhysicalDeviceTileShadingPropertiesQCOM32;
+    VkSubresourceLayout32 DECLSPEC_ALIGN(8) subresourceLayout;
+} VkSubresourceLayout232;
+typedef VkSubresourceLayout232 VkSubresourceLayout2KHR32;
+typedef VkSubresourceLayout232 VkSubresourceLayout2EXT32;

-typedef struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32
+typedef struct VkSurfaceCapabilities2KHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxFragmentDensityMapLayers;
-} VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32;
+    VkSurfaceCapabilitiesKHR surfaceCapabilities;
+} VkSurfaceCapabilities2KHR32;

-typedef struct VkPhysicalDeviceTensorPropertiesARM32
+typedef struct VkSurfaceCapabilitiesPresentBarrierNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t maxTensorDimensionCount;
-    uint64_t DECLSPEC_ALIGN(8) maxTensorElements;
-    uint64_t DECLSPEC_ALIGN(8) maxPerDimensionTensorElements;
-    int64_t maxTensorStride;
-    uint64_t DECLSPEC_ALIGN(8) maxTensorSize;
-    uint32_t maxTensorShaderAccessArrayLength;
-    uint32_t maxTensorShaderAccessSize;
-    uint32_t maxDescriptorSetStorageTensors;
-    uint32_t maxPerStageDescriptorSetStorageTensors;
-    uint32_t maxDescriptorSetUpdateAfterBindStorageTensors;
-    uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors;
-    VkBool32 shaderStorageTensorArrayNonUniformIndexingNative;
-    VkShaderStageFlags shaderTensorSupportedStages;
-} VkPhysicalDeviceTensorPropertiesARM32;
+    VkBool32 presentBarrierSupported;
+} VkSurfaceCapabilitiesPresentBarrierNV32;

-typedef struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32
+typedef struct VkSurfaceCapabilitiesPresentId2KHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 tensorCaptureReplayDescriptorDataSize;
-    PTR32 tensorViewCaptureReplayDescriptorDataSize;
-    PTR32 tensorDescriptorSize;
-} VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32;
+    VkBool32 presentId2Supported;
+} VkSurfaceCapabilitiesPresentId2KHR32;

-typedef struct VkPhysicalDeviceProperties232
+typedef struct VkSurfaceCapabilitiesPresentWait2KHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPhysicalDeviceProperties32 DECLSPEC_ALIGN(8) properties;
-} VkPhysicalDeviceProperties232;
-typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32;
+    VkBool32 presentWait2Supported;
+} VkSurfaceCapabilitiesPresentWait2KHR32;

-typedef struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32
+typedef struct VkSurfaceFormat2KHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t queueFamilyIndex;
-    VkPhysicalDeviceDataGraphProcessingEngineTypeARM engineType;
-} VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32;
+    VkSurfaceFormatKHR surfaceFormat;
+} VkSurfaceFormat2KHR32;

-typedef struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM32
+typedef struct VkSurfacePresentModeCompatibilityKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes;
-    VkExternalMemoryHandleTypeFlags foreignMemoryHandleTypes;
-} VkQueueFamilyDataGraphProcessingEnginePropertiesARM32;
+    uint32_t presentModeCount;
+    PTR32 pPresentModes;
+} VkSurfacePresentModeCompatibilityKHR32;
+typedef VkSurfacePresentModeCompatibilityKHR32 VkSurfacePresentModeCompatibilityEXT32;

-typedef struct VkQueueFamilyDataGraphPropertiesARM32
+typedef struct VkSurfacePresentModeKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPhysicalDeviceDataGraphProcessingEngineARM engine;
-    VkPhysicalDeviceDataGraphOperationSupportARM operation;
-} VkQueueFamilyDataGraphPropertiesARM32;
+    VkPresentModeKHR presentMode;
+} VkSurfacePresentModeKHR32;
+typedef VkSurfacePresentModeKHR32 VkSurfacePresentModeEXT32;

-typedef struct VkQueueFamilyOwnershipTransferPropertiesKHR32
+typedef struct VkSurfacePresentScalingCapabilitiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t optimalImageTransferToQueueFamilies;
-} VkQueueFamilyOwnershipTransferPropertiesKHR32;
+    VkPresentScalingFlagsKHR supportedPresentScaling;
+    VkPresentGravityFlagsKHR supportedPresentGravityX;
+    VkPresentGravityFlagsKHR supportedPresentGravityY;
+    VkExtent2D minScaledImageExtent;
+    VkExtent2D maxScaledImageExtent;
+} VkSurfacePresentScalingCapabilitiesKHR32;
+typedef VkSurfacePresentScalingCapabilitiesKHR32 VkSurfacePresentScalingCapabilitiesEXT32;

-typedef struct VkQueueFamilyGlobalPriorityProperties32
+typedef struct VkSwapchainCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t priorityCount;
-    VkQueueGlobalPriority priorities[VK_MAX_GLOBAL_PRIORITY_SIZE];
-} VkQueueFamilyGlobalPriorityProperties32;
-typedef VkQueueFamilyGlobalPriorityProperties32 VkQueueFamilyGlobalPriorityPropertiesKHR32;
-typedef VkQueueFamilyGlobalPriorityProperties32 VkQueueFamilyGlobalPriorityPropertiesEXT32;
+    VkSwapchainCreateFlagsKHR flags;
+    VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
+    uint32_t minImageCount;
+    VkFormat imageFormat;
+    VkColorSpaceKHR imageColorSpace;
+    VkExtent2D imageExtent;
+    uint32_t imageArrayLayers;
+    VkImageUsageFlags imageUsage;
+    VkSharingMode imageSharingMode;
+    uint32_t queueFamilyIndexCount;
+    PTR32 pQueueFamilyIndices;
+    VkSurfaceTransformFlagBitsKHR preTransform;
+    VkCompositeAlphaFlagBitsKHR compositeAlpha;
+    VkPresentModeKHR presentMode;
+    VkBool32 clipped;
+    VkSwapchainKHR DECLSPEC_ALIGN(8) oldSwapchain;
+} VkSwapchainCreateInfoKHR32;

-typedef struct VkQueueFamilyCheckpointPropertiesNV32
+typedef struct VkSwapchainLatencyCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineStageFlags checkpointExecutionStageMask;
-} VkQueueFamilyCheckpointPropertiesNV32;
+    VkBool32 latencyModeEnable;
+} VkSwapchainLatencyCreateInfoNV32;

-typedef struct VkQueueFamilyCheckpointProperties2NV32
+typedef struct VkSwapchainPresentBarrierCreateInfoNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) checkpointExecutionStageMask;
-} VkQueueFamilyCheckpointProperties2NV32;
+    VkBool32 presentBarrierEnable;
+} VkSwapchainPresentBarrierCreateInfoNV32;

-typedef struct VkQueueFamilyVideoPropertiesKHR32
+typedef struct VkSwapchainPresentFenceInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoCodecOperationFlagsKHR videoCodecOperations;
-} VkQueueFamilyVideoPropertiesKHR32;
+    uint32_t swapchainCount;
+    PTR32 pFences;
+} VkSwapchainPresentFenceInfoKHR32;
+typedef VkSwapchainPresentFenceInfoKHR32 VkSwapchainPresentFenceInfoEXT32;

-typedef struct VkQueueFamilyQueryResultStatusPropertiesKHR32
+typedef struct VkSwapchainPresentModeInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 queryResultStatusSupport;
-} VkQueueFamilyQueryResultStatusPropertiesKHR32;
+    uint32_t swapchainCount;
+    PTR32 pPresentModes;
+} VkSwapchainPresentModeInfoKHR32;
+typedef VkSwapchainPresentModeInfoKHR32 VkSwapchainPresentModeInfoEXT32;

-typedef struct VkQueueFamilyProperties232
+typedef struct VkSwapchainPresentModesCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkQueueFamilyProperties queueFamilyProperties;
-} VkQueueFamilyProperties232;
-typedef VkQueueFamilyProperties232 VkQueueFamilyProperties2KHR32;
+    uint32_t presentModeCount;
+    PTR32 pPresentModes;
+} VkSwapchainPresentModesCreateInfoKHR32;
+typedef VkSwapchainPresentModesCreateInfoKHR32 VkSwapchainPresentModesCreateInfoEXT32;

-typedef struct VkPhysicalDeviceSparseImageFormatInfo232
+typedef struct VkSwapchainPresentScalingCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkFormat format;
-    VkImageType type;
-    VkSampleCountFlagBits samples;
-    VkImageUsageFlags usage;
-    VkImageTiling tiling;
-} VkPhysicalDeviceSparseImageFormatInfo232;
-typedef VkPhysicalDeviceSparseImageFormatInfo232 VkPhysicalDeviceSparseImageFormatInfo2KHR32;
+    VkPresentScalingFlagsKHR scalingBehavior;
+    VkPresentGravityFlagsKHR presentGravityX;
+    VkPresentGravityFlagsKHR presentGravityY;
+} VkSwapchainPresentScalingCreateInfoKHR32;
+typedef VkSwapchainPresentScalingCreateInfoKHR32 VkSwapchainPresentScalingCreateInfoEXT32;

-typedef struct VkSparseImageFormatProperties232
+typedef struct VkTensorCaptureDescriptorDataInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSparseImageFormatProperties properties;
-} VkSparseImageFormatProperties232;
-typedef VkSparseImageFormatProperties232 VkSparseImageFormatProperties2KHR32;
+    VkTensorARM DECLSPEC_ALIGN(8) tensor;
+} VkTensorCaptureDescriptorDataInfoARM32;

-typedef struct VkFramebufferMixedSamplesCombinationNV32
+typedef struct VkTensorDependencyInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkCoverageReductionModeNV coverageReductionMode;
-    VkSampleCountFlagBits rasterizationSamples;
-    VkSampleCountFlags depthStencilSamples;
-    VkSampleCountFlags colorSamples;
-} VkFramebufferMixedSamplesCombinationNV32;
+    uint32_t tensorMemoryBarrierCount;
+    PTR32 pTensorMemoryBarriers;
+} VkTensorDependencyInfoARM32;

-typedef struct VkSurfacePresentModeKHR32
+typedef struct VkTensorFormatPropertiesARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPresentModeKHR presentMode;
-} VkSurfacePresentModeKHR32;
-typedef VkSurfacePresentModeKHR32 VkSurfacePresentModeEXT32;
+    VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingTensorFeatures;
+    VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingTensorFeatures;
+} VkTensorFormatPropertiesARM32;

-typedef struct VkPhysicalDeviceSurfaceInfo2KHR32
+typedef struct VkTensorMemoryRequirementsInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
-} VkPhysicalDeviceSurfaceInfo2KHR32;
+    VkTensorARM DECLSPEC_ALIGN(8) tensor;
+} VkTensorMemoryRequirementsInfoARM32;

-typedef struct VkSurfaceCapabilitiesPresentBarrierNV32
+typedef struct VkTensorViewCaptureDescriptorDataInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 presentBarrierSupported;
-} VkSurfaceCapabilitiesPresentBarrierNV32;
+    VkTensorViewARM DECLSPEC_ALIGN(8) tensorView;
+} VkTensorViewCaptureDescriptorDataInfoARM32;

-typedef struct VkSurfaceCapabilitiesPresentId2KHR32
+typedef struct VkTensorViewCreateInfoARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 presentId2Supported;
-} VkSurfaceCapabilitiesPresentId2KHR32;
+    VkTensorViewCreateFlagsARM DECLSPEC_ALIGN(8) flags;
+    VkTensorARM DECLSPEC_ALIGN(8) tensor;
+    VkFormat format;
+} VkTensorViewCreateInfoARM32;

-typedef struct VkSurfaceCapabilitiesPresentWait2KHR32
+typedef struct VkTextureLODGatherFormatPropertiesAMD32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 presentWait2Supported;
-} VkSurfaceCapabilitiesPresentWait2KHR32;
+    VkBool32 supportsTextureGatherLODBiasAMD;
+} VkTextureLODGatherFormatPropertiesAMD32;

-typedef struct VkSurfacePresentScalingCapabilitiesKHR32
+typedef struct VkTileMemoryBindInfoQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPresentScalingFlagsKHR supportedPresentScaling;
-    VkPresentGravityFlagsKHR supportedPresentGravityX;
-    VkPresentGravityFlagsKHR supportedPresentGravityY;
-    VkExtent2D minScaledImageExtent;
-    VkExtent2D maxScaledImageExtent;
-} VkSurfacePresentScalingCapabilitiesKHR32;
-typedef VkSurfacePresentScalingCapabilitiesKHR32 VkSurfacePresentScalingCapabilitiesEXT32;
+    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
+} VkTileMemoryBindInfoQCOM32;

-typedef struct VkSurfacePresentModeCompatibilityKHR32
+typedef struct VkTileMemoryRequirementsQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t presentModeCount;
-    PTR32 pPresentModes;
-} VkSurfacePresentModeCompatibilityKHR32;
-typedef VkSurfacePresentModeCompatibilityKHR32 VkSurfacePresentModeCompatibilityEXT32;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+    VkDeviceSize DECLSPEC_ALIGN(8) alignment;
+} VkTileMemoryRequirementsQCOM32;

-typedef struct VkLatencySurfaceCapabilitiesNV32
+typedef struct VkTileMemorySizeInfoQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t presentModeCount;
-    PTR32 pPresentModes;
-} VkLatencySurfaceCapabilitiesNV32;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+} VkTileMemorySizeInfoQCOM32;

-typedef struct VkSurfaceCapabilities2KHR32
+typedef struct VkTilePropertiesQCOM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSurfaceCapabilitiesKHR surfaceCapabilities;
-} VkSurfaceCapabilities2KHR32;
+    VkExtent3D tileSize;
+    VkExtent2D apronSize;
+    VkOffset2D origin;
+} VkTilePropertiesQCOM32;

-typedef struct VkSurfaceFormat2KHR32
+typedef struct VkTimelineSemaphoreSubmitInfo32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSurfaceFormatKHR surfaceFormat;
-} VkSurfaceFormat2KHR32;
+    uint32_t waitSemaphoreValueCount;
+    PTR32 pWaitSemaphoreValues;
+    uint32_t signalSemaphoreValueCount;
+    PTR32 pSignalSemaphoreValues;
+} VkTimelineSemaphoreSubmitInfo32;
+typedef VkTimelineSemaphoreSubmitInfo32 VkTimelineSemaphoreSubmitInfoKHR32;

-typedef struct VkPhysicalDeviceToolProperties32
+typedef struct VkValidationCacheCreateInfoEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    char name[VK_MAX_EXTENSION_NAME_SIZE];
-    char version[VK_MAX_EXTENSION_NAME_SIZE];
-    VkToolPurposeFlags purposes;
-    char description[VK_MAX_DESCRIPTION_SIZE];
-    char layer[VK_MAX_EXTENSION_NAME_SIZE];
-} VkPhysicalDeviceToolProperties32;
-typedef VkPhysicalDeviceToolProperties32 VkPhysicalDeviceToolPropertiesEXT32;
+    VkValidationCacheCreateFlagsEXT flags;
+    PTR32 initialDataSize;
+    PTR32 pInitialData;
+} VkValidationCacheCreateInfoEXT32;

-typedef struct VkVideoEncodeQuantizationMapCapabilitiesKHR32
+typedef struct VkValidationFeaturesEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExtent2D maxQuantizationMapExtent;
-} VkVideoEncodeQuantizationMapCapabilitiesKHR32;
+    uint32_t enabledValidationFeatureCount;
+    PTR32 pEnabledValidationFeatures;
+    uint32_t disabledValidationFeatureCount;
+    PTR32 pDisabledValidationFeatures;
+} VkValidationFeaturesEXT32;

-typedef struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR32
+typedef struct VkValidationFlagsEXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    int32_t minQpDelta;
-    int32_t maxQpDelta;
-} VkVideoEncodeH264QuantizationMapCapabilitiesKHR32;
+    uint32_t disabledValidationCheckCount;
+    PTR32 pDisabledValidationChecks;
+} VkValidationFlagsEXT32;

-typedef struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR32
+typedef struct VkVertexInputAttributeDescription2EXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    int32_t minQpDelta;
-    int32_t maxQpDelta;
-} VkVideoEncodeH265QuantizationMapCapabilitiesKHR32;
+    uint32_t location;
+    uint32_t binding;
+    VkFormat format;
+    uint32_t offset;
+} VkVertexInputAttributeDescription2EXT32;

-typedef struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32
+typedef struct VkVertexInputBindingDescription2EXT32
 {
     VkStructureType sType;
     PTR32 pNext;
-    int32_t minQIndexDelta;
-    int32_t maxQIndexDelta;
-} VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32;
+    uint32_t binding;
+    uint32_t stride;
+    VkVertexInputRate inputRate;
+    uint32_t divisor;
+} VkVertexInputBindingDescription2EXT32;

-typedef struct VkVideoDecodeCapabilitiesKHR32
+typedef struct VkVideoBeginCodingInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoDecodeCapabilityFlagsKHR flags;
-} VkVideoDecodeCapabilitiesKHR32;
+    VkVideoBeginCodingFlagsKHR flags;
+    VkVideoSessionKHR DECLSPEC_ALIGN(8) videoSession;
+    VkVideoSessionParametersKHR DECLSPEC_ALIGN(8) videoSessionParameters;
+    uint32_t referenceSlotCount;
+    PTR32 pReferenceSlots;
+} VkVideoBeginCodingInfoKHR32;

-typedef struct VkVideoDecodeH264CapabilitiesKHR32
+typedef struct VkVideoCapabilitiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    StdVideoH264LevelIdc maxLevelIdc;
-    VkOffset2D fieldOffsetGranularity;
-} VkVideoDecodeH264CapabilitiesKHR32;
+    VkVideoCapabilityFlagsKHR flags;
+    VkDeviceSize DECLSPEC_ALIGN(8) minBitstreamBufferOffsetAlignment;
+    VkDeviceSize DECLSPEC_ALIGN(8) minBitstreamBufferSizeAlignment;
+    VkExtent2D pictureAccessGranularity;
+    VkExtent2D minCodedExtent;
+    VkExtent2D maxCodedExtent;
+    uint32_t maxDpbSlots;
+    uint32_t maxActiveReferencePictures;
+    VkExtensionProperties stdHeaderVersion;
+} VkVideoCapabilitiesKHR32;

-typedef struct VkVideoDecodeVP9CapabilitiesKHR32
+typedef struct VkVideoCodingControlInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    StdVideoVP9Level maxLevel;
-} VkVideoDecodeVP9CapabilitiesKHR32;
+    VkVideoCodingControlFlagsKHR flags;
+} VkVideoCodingControlInfoKHR32;

typedef struct VkVideoDecodeAV1CapabilitiesKHR32
 {
@@ -8726,760 +8821,691 @@ typedef struct VkVideoDecodeAV1CapabilitiesKHR32
     StdVideoAV1Level maxLevel;
 } VkVideoDecodeAV1CapabilitiesKHR32;

-typedef struct VkVideoEncodeCapabilitiesKHR32
+typedef struct VkVideoDecodeAV1DpbSlotInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeCapabilityFlagsKHR flags;
-    VkVideoEncodeRateControlModeFlagsKHR rateControlModes;
-    uint32_t maxRateControlLayers;
-    uint64_t DECLSPEC_ALIGN(8) maxBitrate;
-    uint32_t maxQualityLevels;
-    VkExtent2D encodeInputPictureGranularity;
-    VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags;
-} VkVideoEncodeCapabilitiesKHR32;
+    PTR32 pStdReferenceInfo;
+} VkVideoDecodeAV1DpbSlotInfoKHR32;

-typedef struct VkVideoEncodeH264CapabilitiesKHR32
+typedef struct VkVideoDecodeAV1PictureInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeH264CapabilityFlagsKHR flags;
-    StdVideoH264LevelIdc maxLevelIdc;
-    uint32_t maxSliceCount;
-    uint32_t maxPPictureL0ReferenceCount;
-    uint32_t maxBPictureL0ReferenceCount;
-    uint32_t maxL1ReferenceCount;
-    uint32_t maxTemporalLayerCount;
-    VkBool32 expectDyadicTemporalLayerPattern;
-    int32_t minQp;
-    int32_t maxQp;
-    VkBool32 prefersGopRemainingFrames;
-    VkBool32 requiresGopRemainingFrames;
-    VkVideoEncodeH264StdFlagsKHR stdSyntaxFlags;
-} VkVideoEncodeH264CapabilitiesKHR32;
+    PTR32 pStdPictureInfo;
+    int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR];
+    uint32_t frameHeaderOffset;
+    uint32_t tileCount;
+    PTR32 pTileOffsets;
+    PTR32 pTileSizes;
+} VkVideoDecodeAV1PictureInfoKHR32;

-typedef struct VkVideoEncodeAV1CapabilitiesKHR32
+typedef struct VkVideoDecodeAV1ProfileInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeAV1CapabilityFlagsKHR flags;
-    StdVideoAV1Level maxLevel;
-    VkExtent2D codedPictureAlignment;
-    VkExtent2D maxTiles;
-    VkExtent2D minTileSize;
-    VkExtent2D maxTileSize;
-    VkVideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes;
-    uint32_t maxSingleReferenceCount;
-    uint32_t singleReferenceNameMask;
-    uint32_t maxUnidirectionalCompoundReferenceCount;
-    uint32_t maxUnidirectionalCompoundGroup1ReferenceCount;
-    uint32_t unidirectionalCompoundReferenceNameMask;
-    uint32_t maxBidirectionalCompoundReferenceCount;
-    uint32_t maxBidirectionalCompoundGroup1ReferenceCount;
-    uint32_t maxBidirectionalCompoundGroup2ReferenceCount;
-    uint32_t bidirectionalCompoundReferenceNameMask;
-    uint32_t maxTemporalLayerCount;
-    uint32_t maxSpatialLayerCount;
-    uint32_t maxOperatingPoints;
-    uint32_t minQIndex;
-    uint32_t maxQIndex;
-    VkBool32 prefersGopRemainingFrames;
-    VkBool32 requiresGopRemainingFrames;
-    VkVideoEncodeAV1StdFlagsKHR stdSyntaxFlags;
-} VkVideoEncodeAV1CapabilitiesKHR32;
+    StdVideoAV1Profile stdProfile;
+    VkBool32 filmGrainSupport;
+} VkVideoDecodeAV1ProfileInfoKHR32;

-typedef struct VkVideoEncodeIntraRefreshCapabilitiesKHR32
+typedef struct VkVideoDecodeAV1SessionParametersCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes;
-    uint32_t maxIntraRefreshCycleDuration;
-    uint32_t maxIntraRefreshActiveReferencePictures;
-    VkBool32 partitionIndependentIntraRefreshRegions;
-    VkBool32 nonRectangularIntraRefreshRegions;
-} VkVideoEncodeIntraRefreshCapabilitiesKHR32;
+    PTR32 pStdSequenceHeader;
+} VkVideoDecodeAV1SessionParametersCreateInfoKHR32;

-typedef struct VkVideoCapabilitiesKHR32
+typedef struct VkVideoDecodeCapabilitiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoCapabilityFlagsKHR flags;
-    VkDeviceSize DECLSPEC_ALIGN(8) minBitstreamBufferOffsetAlignment;
-    VkDeviceSize DECLSPEC_ALIGN(8) minBitstreamBufferSizeAlignment;
-    VkExtent2D pictureAccessGranularity;
-    VkExtent2D minCodedExtent;
-    VkExtent2D maxCodedExtent;
-    uint32_t maxDpbSlots;
-    uint32_t maxActiveReferencePictures;
-    VkExtensionProperties stdHeaderVersion;
-} VkVideoCapabilitiesKHR32;
+    VkVideoDecodeCapabilityFlagsKHR flags;
+} VkVideoDecodeCapabilitiesKHR32;

-typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR32
+typedef struct VkVideoDecodeH264CapabilitiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pVideoProfile;
-    uint32_t qualityLevel;
-} VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR32;
+    StdVideoH264LevelIdc maxLevelIdc;
+    VkOffset2D fieldOffsetGranularity;
+} VkVideoDecodeH264CapabilitiesKHR32;

-typedef struct VkVideoEncodeH264QualityLevelPropertiesKHR32
+typedef struct VkVideoDecodeH264DpbSlotInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeH264RateControlFlagsKHR preferredRateControlFlags;
-    uint32_t preferredGopFrameCount;
-    uint32_t preferredIdrPeriod;
-    uint32_t preferredConsecutiveBFrameCount;
-    uint32_t preferredTemporalLayerCount;
-    VkVideoEncodeH264QpKHR preferredConstantQp;
-    uint32_t preferredMaxL0ReferenceCount;
-    uint32_t preferredMaxL1ReferenceCount;
-    VkBool32 preferredStdEntropyCodingModeFlag;
-} VkVideoEncodeH264QualityLevelPropertiesKHR32;
+    PTR32 pStdReferenceInfo;
+} VkVideoDecodeH264DpbSlotInfoKHR32;

-typedef struct VkVideoEncodeAV1QualityLevelPropertiesKHR32
+typedef struct VkVideoDecodeH264PictureInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags;
-    uint32_t preferredGopFrameCount;
-    uint32_t preferredKeyFramePeriod;
-    uint32_t preferredConsecutiveBipredictiveFrameCount;
-    uint32_t preferredTemporalLayerCount;
-    VkVideoEncodeAV1QIndexKHR preferredConstantQIndex;
-    uint32_t preferredMaxSingleReferenceCount;
-    uint32_t preferredSingleReferenceNameMask;
-    uint32_t preferredMaxUnidirectionalCompoundReferenceCount;
-    uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount;
-    uint32_t preferredUnidirectionalCompoundReferenceNameMask;
-    uint32_t preferredMaxBidirectionalCompoundReferenceCount;
-    uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount;
-    uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount;
-    uint32_t preferredBidirectionalCompoundReferenceNameMask;
-} VkVideoEncodeAV1QualityLevelPropertiesKHR32;
+    PTR32 pStdPictureInfo;
+    uint32_t sliceCount;
+    PTR32 pSliceOffsets;
+} VkVideoDecodeH264PictureInfoKHR32;
+
+typedef struct VkVideoDecodeH264ProfileInfoKHR32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    StdVideoH264ProfileIdc stdProfileIdc;
+    VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout;
+} VkVideoDecodeH264ProfileInfoKHR32;

-typedef struct VkVideoEncodeQualityLevelPropertiesKHR32
+typedef struct VkVideoDecodeH264SessionParametersCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode;
-    uint32_t preferredRateControlLayerCount;
-} VkVideoEncodeQualityLevelPropertiesKHR32;
+    uint32_t maxStdSPSCount;
+    uint32_t maxStdPPSCount;
+    PTR32 pParametersAddInfo;
+} VkVideoDecodeH264SessionParametersCreateInfoKHR32;

-typedef struct VkPhysicalDeviceVideoFormatInfoKHR32
+typedef struct VkVideoDecodeInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImageUsageFlags imageUsage;
-} VkPhysicalDeviceVideoFormatInfoKHR32;
+    VkVideoDecodeFlagsKHR flags;
+    VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
+    VkDeviceSize DECLSPEC_ALIGN(8) srcBufferOffset;
+    VkDeviceSize DECLSPEC_ALIGN(8) srcBufferRange;
+    VkVideoPictureResourceInfoKHR32 DECLSPEC_ALIGN(8) dstPictureResource;
+    PTR32 pSetupReferenceSlot;
+    uint32_t referenceSlotCount;
+    PTR32 pReferenceSlots;
+} VkVideoDecodeInfoKHR32;

-typedef struct VkVideoFormatQuantizationMapPropertiesKHR32
+typedef struct VkVideoDecodeUsageInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkExtent2D quantizationMapTexelSize;
-} VkVideoFormatQuantizationMapPropertiesKHR32;
+    VkVideoDecodeUsageFlagsKHR videoUsageHints;
+} VkVideoDecodeUsageInfoKHR32;

-typedef struct VkVideoFormatH265QuantizationMapPropertiesKHR32
+typedef struct VkVideoDecodeVP9CapabilitiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes;
-} VkVideoFormatH265QuantizationMapPropertiesKHR32;
+    StdVideoVP9Level maxLevel;
+} VkVideoDecodeVP9CapabilitiesKHR32;

-typedef struct VkVideoFormatAV1QuantizationMapPropertiesKHR32
+typedef struct VkVideoDecodeVP9PictureInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkVideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes;
-} VkVideoFormatAV1QuantizationMapPropertiesKHR32;
+    PTR32 pStdPictureInfo;
+    int32_t referenceNameSlotIndices[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR];
+    uint32_t uncompressedHeaderOffset;
+    uint32_t compressedHeaderOffset;
+    uint32_t tilesOffset;
+} VkVideoDecodeVP9PictureInfoKHR32;

-typedef struct VkVideoFormatPropertiesKHR32
+typedef struct VkVideoDecodeVP9ProfileInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkFormat format;
-    VkComponentMapping componentMapping;
-    VkImageCreateFlags imageCreateFlags;
-    VkImageType imageType;
-    VkImageTiling imageTiling;
-    VkImageUsageFlags imageUsageFlags;
-} VkVideoFormatPropertiesKHR32;
+    StdVideoVP9Profile stdProfile;
+} VkVideoDecodeVP9ProfileInfoKHR32;

-typedef struct VkPipelineBinaryDataInfoKHR32
+typedef struct VkVideoEncodeAV1CapabilitiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineBinaryKHR DECLSPEC_ALIGN(8) pipelineBinary;
-} VkPipelineBinaryDataInfoKHR32;
+    VkVideoEncodeAV1CapabilityFlagsKHR flags;
+    StdVideoAV1Level maxLevel;
+    VkExtent2D codedPictureAlignment;
+    VkExtent2D maxTiles;
+    VkExtent2D minTileSize;
+    VkExtent2D maxTileSize;
+    VkVideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes;
+    uint32_t maxSingleReferenceCount;
+    uint32_t singleReferenceNameMask;
+    uint32_t maxUnidirectionalCompoundReferenceCount;
+    uint32_t maxUnidirectionalCompoundGroup1ReferenceCount;
+    uint32_t unidirectionalCompoundReferenceNameMask;
+    uint32_t maxBidirectionalCompoundReferenceCount;
+    uint32_t maxBidirectionalCompoundGroup1ReferenceCount;
+    uint32_t maxBidirectionalCompoundGroup2ReferenceCount;
+    uint32_t bidirectionalCompoundReferenceNameMask;
+    uint32_t maxTemporalLayerCount;
+    uint32_t maxSpatialLayerCount;
+    uint32_t maxOperatingPoints;
+    uint32_t minQIndex;
+    uint32_t maxQIndex;
+    VkBool32 prefersGopRemainingFrames;
+    VkBool32 requiresGopRemainingFrames;
+    VkVideoEncodeAV1StdFlagsKHR stdSyntaxFlags;
+} VkVideoEncodeAV1CapabilitiesKHR32;

-typedef struct VkPipelineExecutableInfoKHR32
+typedef struct VkVideoEncodeAV1DpbSlotInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipeline DECLSPEC_ALIGN(8) pipeline;
-    uint32_t executableIndex;
-} VkPipelineExecutableInfoKHR32;
+    PTR32 pStdReferenceInfo;
+} VkVideoEncodeAV1DpbSlotInfoKHR32;

-typedef struct VkPipelineExecutableInternalRepresentationKHR32
+typedef struct VkVideoEncodeAV1GopRemainingFrameInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    char name[VK_MAX_DESCRIPTION_SIZE];
-    char description[VK_MAX_DESCRIPTION_SIZE];
-    VkBool32 isText;
-    PTR32 dataSize;
-    PTR32 pData;
-} VkPipelineExecutableInternalRepresentationKHR32;
+    VkBool32 useGopRemainingFrames;
+    uint32_t gopRemainingIntra;
+    uint32_t gopRemainingPredictive;
+    uint32_t gopRemainingBipredictive;
+} VkVideoEncodeAV1GopRemainingFrameInfoKHR32;

-typedef struct VkPipelineInfoKHR32
+typedef struct VkVideoEncodeAV1PictureInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipeline DECLSPEC_ALIGN(8) pipeline;
-} VkPipelineInfoKHR32;
-typedef VkPipelineInfoKHR32 VkPipelineInfoEXT32;
+    VkVideoEncodeAV1PredictionModeKHR predictionMode;
+    VkVideoEncodeAV1RateControlGroupKHR rateControlGroup;
+    uint32_t constantQIndex;
+    PTR32 pStdPictureInfo;
+    int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR];
+    VkBool32 primaryReferenceCdfOnly;
+    VkBool32 generateObuExtensionHeader;
+} VkVideoEncodeAV1PictureInfoKHR32;

-typedef struct VkPipelineExecutablePropertiesKHR32
+typedef struct VkVideoEncodeAV1ProfileInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkShaderStageFlags stages;
-    char name[VK_MAX_DESCRIPTION_SIZE];
-    char description[VK_MAX_DESCRIPTION_SIZE];
-    uint32_t subgroupSize;
-} VkPipelineExecutablePropertiesKHR32;
+    StdVideoAV1Profile stdProfile;
+} VkVideoEncodeAV1ProfileInfoKHR32;

-typedef union VkPipelineExecutableStatisticValueKHR32
+typedef struct VkVideoEncodeAV1QualityLevelPropertiesKHR32
 {
-    VkBool32 b32;
-    int64_t i64;
-    uint64_t DECLSPEC_ALIGN(8) u64;
-    double f64;
-} VkPipelineExecutableStatisticValueKHR32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkVideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags;
+    uint32_t preferredGopFrameCount;
+    uint32_t preferredKeyFramePeriod;
+    uint32_t preferredConsecutiveBipredictiveFrameCount;
+    uint32_t preferredTemporalLayerCount;
+    VkVideoEncodeAV1QIndexKHR preferredConstantQIndex;
+    uint32_t preferredMaxSingleReferenceCount;
+    uint32_t preferredSingleReferenceNameMask;
+    uint32_t preferredMaxUnidirectionalCompoundReferenceCount;
+    uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount;
+    uint32_t preferredUnidirectionalCompoundReferenceNameMask;
+    uint32_t preferredMaxBidirectionalCompoundReferenceCount;
+    uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount;
+    uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount;
+    uint32_t preferredBidirectionalCompoundReferenceNameMask;
+} VkVideoEncodeAV1QualityLevelPropertiesKHR32;

-typedef struct VkPipelineExecutableStatisticKHR32
+typedef struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    char name[VK_MAX_DESCRIPTION_SIZE];
-    char description[VK_MAX_DESCRIPTION_SIZE];
-    VkPipelineExecutableStatisticFormatKHR format;
-    VkPipelineExecutableStatisticValueKHR32 DECLSPEC_ALIGN(8) value;
-} VkPipelineExecutableStatisticKHR32;
+    int32_t minQIndexDelta;
+    int32_t maxQIndexDelta;
+} VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32;

-typedef struct VkPipelineIndirectDeviceAddressInfoNV32
+typedef struct VkVideoEncodeAV1RateControlInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineBindPoint pipelineBindPoint;
-    VkPipeline DECLSPEC_ALIGN(8) pipeline;
-} VkPipelineIndirectDeviceAddressInfoNV32;
-
+    VkVideoEncodeAV1RateControlFlagsKHR flags;
+    uint32_t gopFrameCount;
+    uint32_t keyFramePeriod;
+    uint32_t consecutiveBipredictiveFrameCount;
+    uint32_t temporalLayerCount;
+} VkVideoEncodeAV1RateControlInfoKHR32;

-typedef struct VkCheckpointData2NV32
+typedef struct VkVideoEncodeAV1RateControlLayerInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
-    PTR32 pCheckpointMarker;
-} VkCheckpointData2NV32;
+    VkBool32 useMinQIndex;
+    VkVideoEncodeAV1QIndexKHR minQIndex;
+    VkBool32 useMaxQIndex;
+    VkVideoEncodeAV1QIndexKHR maxQIndex;
+    VkBool32 useMaxFrameSize;
+    VkVideoEncodeAV1FrameSizeKHR maxFrameSize;
+} VkVideoEncodeAV1RateControlLayerInfoKHR32;

-typedef struct VkCheckpointDataNV32
+typedef struct VkVideoEncodeAV1SessionCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipelineStageFlagBits stage;
-    PTR32 pCheckpointMarker;
-} VkCheckpointDataNV32;
+    VkBool32 useMaxLevel;
+    StdVideoAV1Level maxLevel;
+} VkVideoEncodeAV1SessionCreateInfoKHR32;

-typedef struct VkRenderingAreaInfo32
+typedef struct VkVideoEncodeAV1SessionParametersCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t viewMask;
-    uint32_t colorAttachmentCount;
-    PTR32 pColorAttachmentFormats;
-    VkFormat depthAttachmentFormat;
-    VkFormat stencilAttachmentFormat;
-} VkRenderingAreaInfo32;
-typedef VkRenderingAreaInfo32 VkRenderingAreaInfoKHR32;
+    PTR32 pStdSequenceHeader;
+    PTR32 pStdDecoderModelInfo;
+    uint32_t stdOperatingPointCount;
+    PTR32 pStdOperatingPoints;
+} VkVideoEncodeAV1SessionParametersCreateInfoKHR32;

-typedef struct VkSamplerCaptureDescriptorDataInfoEXT32
+typedef struct VkVideoEncodeCapabilitiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSampler DECLSPEC_ALIGN(8) sampler;
-} VkSamplerCaptureDescriptorDataInfoEXT32;
+    VkVideoEncodeCapabilityFlagsKHR flags;
+    VkVideoEncodeRateControlModeFlagsKHR rateControlModes;
+    uint32_t maxRateControlLayers;
+    uint64_t DECLSPEC_ALIGN(8) maxBitrate;
+    uint32_t maxQualityLevels;
+    VkExtent2D encodeInputPictureGranularity;
+    VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags;
+} VkVideoEncodeCapabilitiesKHR32;

-typedef struct VkShaderModuleIdentifierEXT32
+typedef struct VkVideoEncodeH264CapabilitiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t identifierSize;
-    uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT];
-} VkShaderModuleIdentifierEXT32;
+    VkVideoEncodeH264CapabilityFlagsKHR flags;
+    StdVideoH264LevelIdc maxLevelIdc;
+    uint32_t maxSliceCount;
+    uint32_t maxPPictureL0ReferenceCount;
+    uint32_t maxBPictureL0ReferenceCount;
+    uint32_t maxL1ReferenceCount;
+    uint32_t maxTemporalLayerCount;
+    VkBool32 expectDyadicTemporalLayerPattern;
+    int32_t minQp;
+    int32_t maxQp;
+    VkBool32 prefersGopRemainingFrames;
+    VkBool32 requiresGopRemainingFrames;
+    VkVideoEncodeH264StdFlagsKHR stdSyntaxFlags;
+} VkVideoEncodeH264CapabilitiesKHR32;

-typedef struct VkTensorMemoryRequirementsInfoARM32
+typedef struct VkVideoEncodeH264DpbSlotInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkTensorARM DECLSPEC_ALIGN(8) tensor;
-} VkTensorMemoryRequirementsInfoARM32;
+    PTR32 pStdReferenceInfo;
+} VkVideoEncodeH264DpbSlotInfoKHR32;

-typedef struct VkTensorCaptureDescriptorDataInfoARM32
+typedef struct VkVideoEncodeH264GopRemainingFrameInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkTensorARM DECLSPEC_ALIGN(8) tensor;
-} VkTensorCaptureDescriptorDataInfoARM32;
+    VkBool32 useGopRemainingFrames;
+    uint32_t gopRemainingI;
+    uint32_t gopRemainingP;
+    uint32_t gopRemainingB;
+} VkVideoEncodeH264GopRemainingFrameInfoKHR32;

-typedef struct VkTensorViewCaptureDescriptorDataInfoARM32
+typedef struct VkVideoEncodeH264PictureInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkTensorViewARM DECLSPEC_ALIGN(8) tensorView;
-} VkTensorViewCaptureDescriptorDataInfoARM32;
+    uint32_t naluSliceEntryCount;
+    PTR32 pNaluSliceEntries;
+    PTR32 pStdPictureInfo;
+    VkBool32 generatePrefixNalu;
+} VkVideoEncodeH264PictureInfoKHR32;

-typedef struct VkVideoSessionMemoryRequirementsKHR32
+typedef struct VkVideoEncodeH264ProfileInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t memoryBindIndex;
-    VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
-} VkVideoSessionMemoryRequirementsKHR32;
+    StdVideoH264ProfileIdc stdProfileIdc;
+} VkVideoEncodeH264ProfileInfoKHR32;

-typedef struct VkInitializePerformanceApiInfoINTEL32
+typedef struct VkVideoEncodeH264QualityLevelPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pUserData;
-} VkInitializePerformanceApiInfoINTEL32;
+    VkVideoEncodeH264RateControlFlagsKHR preferredRateControlFlags;
+    uint32_t preferredGopFrameCount;
+    uint32_t preferredIdrPeriod;
+    uint32_t preferredConsecutiveBFrameCount;
+    uint32_t preferredTemporalLayerCount;
+    VkVideoEncodeH264QpKHR preferredConstantQp;
+    uint32_t preferredMaxL0ReferenceCount;
+    uint32_t preferredMaxL1ReferenceCount;
+    VkBool32 preferredStdEntropyCodingModeFlag;
+} VkVideoEncodeH264QualityLevelPropertiesKHR32;

-typedef struct VkLatencySleepInfoNV32
+typedef struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSemaphore DECLSPEC_ALIGN(8) signalSemaphore;
-    uint64_t DECLSPEC_ALIGN(8) value;
-} VkLatencySleepInfoNV32;
+    int32_t minQpDelta;
+    int32_t maxQpDelta;
+} VkVideoEncodeH264QuantizationMapCapabilitiesKHR32;

-typedef struct VkMemoryMapPlacedInfoEXT32
+typedef struct VkVideoEncodeH264RateControlInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 pPlacedAddress;
-} VkMemoryMapPlacedInfoEXT32;
+    VkVideoEncodeH264RateControlFlagsKHR flags;
+    uint32_t gopFrameCount;
+    uint32_t idrPeriod;
+    uint32_t consecutiveBFrameCount;
+    uint32_t temporalLayerCount;
+} VkVideoEncodeH264RateControlInfoKHR32;

-typedef struct VkMemoryMapInfo32
+typedef struct VkVideoEncodeH264RateControlLayerInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkMemoryMapFlags flags;
-    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
-    VkDeviceSize DECLSPEC_ALIGN(8) offset;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-} VkMemoryMapInfo32;
-typedef VkMemoryMapInfo32 VkMemoryMapInfoKHR32;
-
-typedef struct VkSparseMemoryBind32
-{
-    VkDeviceSize DECLSPEC_ALIGN(8) resourceOffset;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
-    VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
-    VkSparseMemoryBindFlags flags;
-} VkSparseMemoryBind32;
-
-typedef struct VkSparseBufferMemoryBindInfo32
-{
-    VkBuffer DECLSPEC_ALIGN(8) buffer;
-    uint32_t bindCount;
-    PTR32 pBinds;
-} VkSparseBufferMemoryBindInfo32;
-
-typedef struct VkSparseImageOpaqueMemoryBindInfo32
-{
-    VkImage DECLSPEC_ALIGN(8) image;
-    uint32_t bindCount;
-    PTR32 pBinds;
-} VkSparseImageOpaqueMemoryBindInfo32;
-
-typedef struct VkSparseImageMemoryBind32
-{
-    VkImageSubresource subresource;
-    VkOffset3D offset;
-    VkExtent3D extent;
-    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
-    VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
-    VkSparseMemoryBindFlags flags;
-} VkSparseImageMemoryBind32;
-
-typedef struct VkSparseImageMemoryBindInfo32
-{
-    VkImage DECLSPEC_ALIGN(8) image;
-    uint32_t bindCount;
-    PTR32 pBinds;
-} VkSparseImageMemoryBindInfo32;
+    VkBool32 useMinQp;
+    VkVideoEncodeH264QpKHR minQp;
+    VkBool32 useMaxQp;
+    VkVideoEncodeH264QpKHR maxQp;
+    VkBool32 useMaxFrameSize;
+    VkVideoEncodeH264FrameSizeKHR maxFrameSize;
+} VkVideoEncodeH264RateControlLayerInfoKHR32;

-typedef struct VkDeviceGroupBindSparseInfo32
+typedef struct VkVideoEncodeH264SessionCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t resourceDeviceIndex;
-    uint32_t memoryDeviceIndex;
-} VkDeviceGroupBindSparseInfo32;
-typedef VkDeviceGroupBindSparseInfo32 VkDeviceGroupBindSparseInfoKHR32;
+    VkBool32 useMaxLevelIdc;
+    StdVideoH264LevelIdc maxLevelIdc;
+} VkVideoEncodeH264SessionCreateInfoKHR32;

-typedef struct VkTimelineSemaphoreSubmitInfo32
+typedef struct VkVideoEncodeH264SessionParametersCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t waitSemaphoreValueCount;
-    PTR32 pWaitSemaphoreValues;
-    uint32_t signalSemaphoreValueCount;
-    PTR32 pSignalSemaphoreValues;
-} VkTimelineSemaphoreSubmitInfo32;
-typedef VkTimelineSemaphoreSubmitInfo32 VkTimelineSemaphoreSubmitInfoKHR32;
+    uint32_t maxStdSPSCount;
+    uint32_t maxStdPPSCount;
+    PTR32 pParametersAddInfo;
+} VkVideoEncodeH264SessionParametersCreateInfoKHR32;

-typedef struct VkFrameBoundaryEXT32
+typedef struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkFrameBoundaryFlagsEXT flags;
-    uint64_t DECLSPEC_ALIGN(8) frameID;
-    uint32_t imageCount;
-    PTR32 pImages;
-    uint32_t bufferCount;
-    PTR32 pBuffers;
-    uint64_t DECLSPEC_ALIGN(8) tagName;
-    PTR32 tagSize;
-    PTR32 pTag;
-} VkFrameBoundaryEXT32;
+    VkBool32 hasStdSPSOverrides;
+    VkBool32 hasStdPPSOverrides;
+} VkVideoEncodeH264SessionParametersFeedbackInfoKHR32;

-typedef struct VkFrameBoundaryTensorsARM32
+typedef struct VkVideoEncodeH264SessionParametersGetInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t tensorCount;
-    PTR32 pTensors;
-} VkFrameBoundaryTensorsARM32;
+    VkBool32 writeStdSPS;
+    VkBool32 writeStdPPS;
+    uint32_t stdSPSId;
+    uint32_t stdPPSId;
+} VkVideoEncodeH264SessionParametersGetInfoKHR32;

-typedef struct VkBindSparseInfo32
+typedef struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t waitSemaphoreCount;
-    PTR32 pWaitSemaphores;
-    uint32_t bufferBindCount;
-    PTR32 pBufferBinds;
-    uint32_t imageOpaqueBindCount;
-    PTR32 pImageOpaqueBinds;
-    uint32_t imageBindCount;
-    PTR32 pImageBinds;
-    uint32_t signalSemaphoreCount;
-    PTR32 pSignalSemaphores;
-} VkBindSparseInfo32;
+    int32_t minQpDelta;
+    int32_t maxQpDelta;
+} VkVideoEncodeH265QuantizationMapCapabilitiesKHR32;

-typedef struct VkOutOfBandQueueTypeInfoNV32
+typedef struct VkVideoEncodeInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkOutOfBandQueueTypeNV queueType;
-} VkOutOfBandQueueTypeInfoNV32;
+    VkVideoEncodeFlagsKHR flags;
+    VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
+    VkDeviceSize DECLSPEC_ALIGN(8) dstBufferOffset;
+    VkDeviceSize DECLSPEC_ALIGN(8) dstBufferRange;
+    VkVideoPictureResourceInfoKHR32 DECLSPEC_ALIGN(8) srcPictureResource;
+    PTR32 pSetupReferenceSlot;
+    uint32_t referenceSlotCount;
+    PTR32 pReferenceSlots;
+    uint32_t precedingExternallyEncodedBytes;
+} VkVideoEncodeInfoKHR32;

-typedef struct VkPresentRegionKHR32
+typedef struct VkVideoEncodeIntraRefreshCapabilitiesKHR32
 {
-    uint32_t rectangleCount;
-    PTR32 pRectangles;
-} VkPresentRegionKHR32;
+    VkStructureType sType;
+    PTR32 pNext;
+    VkVideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes;
+    uint32_t maxIntraRefreshCycleDuration;
+    uint32_t maxIntraRefreshActiveReferencePictures;
+    VkBool32 partitionIndependentIntraRefreshRegions;
+    VkBool32 nonRectangularIntraRefreshRegions;
+} VkVideoEncodeIntraRefreshCapabilitiesKHR32;

-typedef struct VkPresentRegionsKHR32
+typedef struct VkVideoEncodeIntraRefreshInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t swapchainCount;
-    PTR32 pRegions;
-} VkPresentRegionsKHR32;
+    uint32_t intraRefreshCycleDuration;
+    uint32_t intraRefreshIndex;
+} VkVideoEncodeIntraRefreshInfoKHR32;

-typedef struct VkDeviceGroupPresentInfoKHR32
+typedef struct VkVideoEncodeQualityLevelInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t swapchainCount;
-    PTR32 pDeviceMasks;
-    VkDeviceGroupPresentModeFlagBitsKHR mode;
-} VkDeviceGroupPresentInfoKHR32;
+    uint32_t qualityLevel;
+} VkVideoEncodeQualityLevelInfoKHR32;

-typedef struct VkPresentIdKHR32
+typedef struct VkVideoEncodeQualityLevelPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t swapchainCount;
-    PTR32 pPresentIds;
-} VkPresentIdKHR32;
+    VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode;
+    uint32_t preferredRateControlLayerCount;
+} VkVideoEncodeQualityLevelPropertiesKHR32;

-typedef struct VkPresentId2KHR32
+typedef struct VkVideoEncodeQuantizationMapCapabilitiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t swapchainCount;
-    PTR32 pPresentIds;
-} VkPresentId2KHR32;
+    VkExtent2D maxQuantizationMapExtent;
+} VkVideoEncodeQuantizationMapCapabilitiesKHR32;

-typedef struct VkSwapchainPresentFenceInfoKHR32
+typedef struct VkVideoEncodeQuantizationMapInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t swapchainCount;
-    PTR32 pFences;
-} VkSwapchainPresentFenceInfoKHR32;
-typedef VkSwapchainPresentFenceInfoKHR32 VkSwapchainPresentFenceInfoEXT32;
+    VkImageView DECLSPEC_ALIGN(8) quantizationMap;
+    VkExtent2D quantizationMapExtent;
+} VkVideoEncodeQuantizationMapInfoKHR32;

-typedef struct VkSwapchainPresentModeInfoKHR32
+typedef struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t swapchainCount;
-    PTR32 pPresentModes;
-} VkSwapchainPresentModeInfoKHR32;
-typedef VkSwapchainPresentModeInfoKHR32 VkSwapchainPresentModeInfoEXT32;
+    VkExtent2D quantizationMapTexelSize;
+} VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32;

-typedef struct VkPresentInfoKHR32
+typedef struct VkVideoEncodeRateControlInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t waitSemaphoreCount;
-    PTR32 pWaitSemaphores;
-    uint32_t swapchainCount;
-    PTR32 pSwapchains;
-    PTR32 pImageIndices;
-    PTR32 pResults;
-} VkPresentInfoKHR32;
+    VkVideoEncodeRateControlFlagsKHR flags;
+    VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode;
+    uint32_t layerCount;
+    PTR32 pLayers;
+    uint32_t virtualBufferSizeInMs;
+    uint32_t initialVirtualBufferSizeInMs;
+} VkVideoEncodeRateControlInfoKHR32;

-typedef struct VkDeviceGroupSubmitInfo32
+typedef struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t waitSemaphoreCount;
-    PTR32 pWaitSemaphoreDeviceIndices;
-    uint32_t commandBufferCount;
-    PTR32 pCommandBufferDeviceMasks;
-    uint32_t signalSemaphoreCount;
-    PTR32 pSignalSemaphoreDeviceIndices;
-} VkDeviceGroupSubmitInfo32;
-typedef VkDeviceGroupSubmitInfo32 VkDeviceGroupSubmitInfoKHR32;
+    VkVideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode;
+} VkVideoEncodeSessionIntraRefreshCreateInfoKHR32;

-typedef struct VkProtectedSubmitInfo32
+typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 protectedSubmit;
-} VkProtectedSubmitInfo32;
+    VkBool32 hasOverrides;
+} VkVideoEncodeSessionParametersFeedbackInfoKHR32;

-typedef struct VkPerformanceQuerySubmitInfoKHR32
+typedef struct VkVideoEncodeSessionParametersGetInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t counterPassIndex;
-} VkPerformanceQuerySubmitInfoKHR32;
+    VkVideoSessionParametersKHR DECLSPEC_ALIGN(8) videoSessionParameters;
+} VkVideoEncodeSessionParametersGetInfoKHR32;

-typedef struct VkLatencySubmissionPresentIdNV32
+typedef struct VkVideoEncodeUsageInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint64_t DECLSPEC_ALIGN(8) presentID;
-} VkLatencySubmissionPresentIdNV32;
+    VkVideoEncodeUsageFlagsKHR videoUsageHints;
+    VkVideoEncodeContentFlagsKHR videoContentHints;
+    VkVideoEncodeTuningModeKHR tuningMode;
+} VkVideoEncodeUsageInfoKHR32;

-typedef struct VkSubmitInfo32
+typedef struct VkVideoEndCodingInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t waitSemaphoreCount;
-    PTR32 pWaitSemaphores;
-    PTR32 pWaitDstStageMask;
-    uint32_t commandBufferCount;
-    PTR32 pCommandBuffers;
-    uint32_t signalSemaphoreCount;
-    PTR32 pSignalSemaphores;
-} VkSubmitInfo32;
+    VkVideoEndCodingFlagsKHR flags;
+} VkVideoEndCodingInfoKHR32;

-typedef struct VkSemaphoreSubmitInfo32
+typedef struct VkVideoFormatAV1QuantizationMapPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSemaphore DECLSPEC_ALIGN(8) semaphore;
-    uint64_t DECLSPEC_ALIGN(8) value;
-    VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
-    uint32_t deviceIndex;
-} VkSemaphoreSubmitInfo32;
-typedef VkSemaphoreSubmitInfo32 VkSemaphoreSubmitInfoKHR32;
+    VkVideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes;
+} VkVideoFormatAV1QuantizationMapPropertiesKHR32;

-typedef struct VkRenderPassStripeSubmitInfoARM32
+typedef struct VkVideoFormatH265QuantizationMapPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint32_t stripeSemaphoreInfoCount;
-    PTR32 pStripeSemaphoreInfos;
-} VkRenderPassStripeSubmitInfoARM32;
+    VkVideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes;
+} VkVideoFormatH265QuantizationMapPropertiesKHR32;

-typedef struct VkCommandBufferSubmitInfo32
+typedef struct VkVideoFormatPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 commandBuffer;
-    uint32_t deviceMask;
-} VkCommandBufferSubmitInfo32;
-typedef VkCommandBufferSubmitInfo32 VkCommandBufferSubmitInfoKHR32;
+    VkFormat format;
+    VkComponentMapping componentMapping;
+    VkImageCreateFlags imageCreateFlags;
+    VkImageType imageType;
+    VkImageTiling imageTiling;
+    VkImageUsageFlags imageUsageFlags;
+} VkVideoFormatPropertiesKHR32;

-typedef struct VkSubmitInfo232
+typedef struct VkVideoFormatQuantizationMapPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSubmitFlags flags;
-    uint32_t waitSemaphoreInfoCount;
-    PTR32 pWaitSemaphoreInfos;
-    uint32_t commandBufferInfoCount;
-    PTR32 pCommandBufferInfos;
-    uint32_t signalSemaphoreInfoCount;
-    PTR32 pSignalSemaphoreInfos;
-} VkSubmitInfo232;
-typedef VkSubmitInfo232 VkSubmitInfo2KHR32;
+    VkExtent2D quantizationMapTexelSize;
+} VkVideoFormatQuantizationMapPropertiesKHR32;

-typedef struct VkReleaseCapturedPipelineDataInfoKHR32
+typedef struct VkVideoInlineQueryInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkPipeline DECLSPEC_ALIGN(8) pipeline;
-} VkReleaseCapturedPipelineDataInfoKHR32;
+    VkQueryPool DECLSPEC_ALIGN(8) queryPool;
+    uint32_t firstQuery;
+    uint32_t queryCount;
+} VkVideoInlineQueryInfoKHR32;

-typedef struct VkReleaseSwapchainImagesInfoKHR32
+typedef struct VkVideoProfileListInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
-    uint32_t imageIndexCount;
-    PTR32 pImageIndices;
-} VkReleaseSwapchainImagesInfoKHR32;
-typedef VkReleaseSwapchainImagesInfoKHR32 VkReleaseSwapchainImagesInfoEXT32;
+    uint32_t profileCount;
+    PTR32 pProfiles;
+} VkVideoProfileListInfoKHR32;

-typedef struct VkDebugUtilsObjectTagInfoEXT32
+typedef struct VkVideoReferenceIntraRefreshInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkObjectType objectType;
-    uint64_t DECLSPEC_ALIGN(8) objectHandle;
-    uint64_t DECLSPEC_ALIGN(8) tagName;
-    PTR32 tagSize;
-    PTR32 pTag;
-} VkDebugUtilsObjectTagInfoEXT32;
+    uint32_t dirtyIntraRefreshRegions;
+} VkVideoReferenceIntraRefreshInfoKHR32;

-typedef struct VkHdrVividDynamicMetadataHUAWEI32
+typedef struct VkVideoSessionCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    PTR32 dynamicMetadataSize;
-    PTR32 pDynamicMetadata;
-} VkHdrVividDynamicMetadataHUAWEI32;
+    uint32_t queueFamilyIndex;
+    VkVideoSessionCreateFlagsKHR flags;
+    PTR32 pVideoProfile;
+    VkFormat pictureFormat;
+    VkExtent2D maxCodedExtent;
+    VkFormat referencePictureFormat;
+    uint32_t maxDpbSlots;
+    uint32_t maxActiveReferencePictures;
+    PTR32 pStdHeaderVersion;
+} VkVideoSessionCreateInfoKHR32;

-typedef struct VkHdrMetadataEXT32
+typedef struct VkVideoSessionMemoryRequirementsKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkXYColorEXT displayPrimaryRed;
-    VkXYColorEXT displayPrimaryGreen;
-    VkXYColorEXT displayPrimaryBlue;
-    VkXYColorEXT whitePoint;
-    float maxLuminance;
-    float minLuminance;
-    float maxContentLightLevel;
-    float maxFrameAverageLightLevel;
-} VkHdrMetadataEXT32;
+    uint32_t memoryBindIndex;
+    VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
+} VkVideoSessionMemoryRequirementsKHR32;

-typedef struct VkSetLatencyMarkerInfoNV32
+typedef struct VkVideoSessionParametersCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    uint64_t DECLSPEC_ALIGN(8) presentID;
-    VkLatencyMarkerNV marker;
-} VkSetLatencyMarkerInfoNV32;
+    VkVideoSessionParametersCreateFlagsKHR flags;
+    VkVideoSessionParametersKHR DECLSPEC_ALIGN(8) videoSessionParametersTemplate;
+    VkVideoSessionKHR DECLSPEC_ALIGN(8) videoSession;
+} VkVideoSessionParametersCreateInfoKHR32;

-typedef struct VkLatencySleepModeInfoNV32
+typedef struct VkVideoSessionParametersUpdateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkBool32 lowLatencyMode;
-    VkBool32 lowLatencyBoost;
-    uint32_t minimumIntervalUs;
-} VkLatencySleepModeInfoNV32;
+    uint32_t updateSequenceCount;
+} VkVideoSessionParametersUpdateInfoKHR32;

-typedef struct VkSemaphoreSignalInfo32
+typedef struct VkWin32SurfaceCreateInfoKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkSemaphore DECLSPEC_ALIGN(8) semaphore;
-    uint64_t DECLSPEC_ALIGN(8) value;
-} VkSemaphoreSignalInfo32;
-typedef VkSemaphoreSignalInfo32 VkSemaphoreSignalInfoKHR32;
+    VkWin32SurfaceCreateFlagsKHR flags;
+    PTR32 hinstance;
+    PTR32 hwnd;
+} VkWin32SurfaceCreateInfoKHR32;

-typedef struct VkDeviceAddressBindingCallbackDataEXT32
+typedef struct VkWriteDescriptorSetAccelerationStructureKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDeviceAddressBindingFlagsEXT flags;
-    VkDeviceAddress DECLSPEC_ALIGN(8) baseAddress;
-    VkDeviceSize DECLSPEC_ALIGN(8) size;
-    VkDeviceAddressBindingTypeEXT bindingType;
-} VkDeviceAddressBindingCallbackDataEXT32;
+    uint32_t accelerationStructureCount;
+    PTR32 pAccelerationStructures;
+} VkWriteDescriptorSetAccelerationStructureKHR32;

-typedef struct VkDebugUtilsMessengerCallbackDataEXT32
+typedef struct VkWriteDescriptorSetAccelerationStructureNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDebugUtilsMessengerCallbackDataFlagsEXT flags;
-    PTR32 pMessageIdName;
-    int32_t messageIdNumber;
-    PTR32 pMessage;
-    uint32_t queueLabelCount;
-    PTR32 pQueueLabels;
-    uint32_t cmdBufLabelCount;
-    PTR32 pCmdBufLabels;
-    uint32_t objectCount;
-    PTR32 pObjects;
-} VkDebugUtilsMessengerCallbackDataEXT32;
+    uint32_t accelerationStructureCount;
+    PTR32 pAccelerationStructures;
+} VkWriteDescriptorSetAccelerationStructureNV32;

-typedef struct VkHostImageLayoutTransitionInfo32
+typedef struct VkWriteDescriptorSetInlineUniformBlock32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkImage DECLSPEC_ALIGN(8) image;
-    VkImageLayout oldLayout;
-    VkImageLayout newLayout;
-    VkImageSubresourceRange subresourceRange;
-} VkHostImageLayoutTransitionInfo32;
-typedef VkHostImageLayoutTransitionInfo32 VkHostImageLayoutTransitionInfoEXT32;
+    uint32_t dataSize;
+    PTR32 pData;
+} VkWriteDescriptorSetInlineUniformBlock32;
+typedef VkWriteDescriptorSetInlineUniformBlock32 VkWriteDescriptorSetInlineUniformBlockEXT32;

-typedef struct VkMemoryUnmapInfo32
+typedef struct VkWriteDescriptorSetPartitionedAccelerationStructureNV32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkMemoryUnmapFlags flags;
-    VkDeviceMemory DECLSPEC_ALIGN(8) memory;
-} VkMemoryUnmapInfo32;
-typedef VkMemoryUnmapInfo32 VkMemoryUnmapInfoKHR32;
+    uint32_t accelerationStructureCount;
+    PTR32 pAccelerationStructures;
+} VkWriteDescriptorSetPartitionedAccelerationStructureNV32;

-typedef struct VkCopyDescriptorSet32
+typedef struct VkWriteDescriptorSetTensorARM32
 {
     VkStructureType sType;
     PTR32 pNext;
-    VkDescriptorSet DECLSPEC_ALIGN(8) srcSet;
-    uint32_t srcBinding;
-    uint32_t srcArrayElement;
-    VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
-    uint32_t dstBinding;
-    uint32_t dstArrayElement;
-    uint32_t descriptorCount;
-} VkCopyDescriptorSet32;
+    uint32_t tensorViewCount;
+    PTR32 pTensorViews;
+} VkWriteDescriptorSetTensorARM32;

typedef struct VkWriteIndirectExecutionSetPipelineEXT32
 {
@@ -9497,32 +9523,6 @@ typedef struct VkWriteIndirectExecutionSetShaderEXT32
     VkShaderEXT DECLSPEC_ALIGN(8) shader;
 } VkWriteIndirectExecutionSetShaderEXT32;

-typedef struct VkVideoSessionParametersUpdateInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    uint32_t updateSequenceCount;
-} VkVideoSessionParametersUpdateInfoKHR32;
-
-typedef struct VkPresentWait2InfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    uint64_t DECLSPEC_ALIGN(8) presentId;
-    uint64_t DECLSPEC_ALIGN(8) timeout;
-} VkPresentWait2InfoKHR32;
-
-typedef struct VkSemaphoreWaitInfo32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkSemaphoreWaitFlags flags;
-    uint32_t semaphoreCount;
-    PTR32 pSemaphores;
-    PTR32 pValues;
-} VkSemaphoreWaitInfo32;
-typedef VkSemaphoreWaitInfo32 VkSemaphoreWaitInfoKHR32;
-
 static uint64_t wine_vk_unwrap_handle(uint32_t type, uint64_t handle)
 {
     switch(type)

[PATCH v2 2/5] winevulkan: Simplify struct conversion enumeration.

[Rémi Bernon]

From: Rémi Bernon

Returning the conversions as they as used, instead of a separate and
possibly different enumeration.
---
 dlls/winevulkan/make_vulkan     |  183 +-
 dlls/winevulkan/vulkan_thunks.c | 5290 +++++++++++++++----------------
 2 files changed, 2710 insertions(+), 2763 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 9be7ef8ca66..68d0673719a 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -657,18 +657,6 @@ class VkFunction(object):

return VkFunction(_type=func_type, name=func_name, params=params)

-    def get_conversions(self):
-        """ Get a list of conversion functions required for this function if any.
-        Parameters which are structures may require conversion between win32
-        and the host platform. This function returns a list of conversions
-        required.
-        """
-
-        conversions = []
-        for param in self.params:
-            conversions.extend(param.get_conversions(self.unwrap))
-        return conversions
-
     def is_alias(self):
         return bool(self.alias)

@@ -806,7 +794,7 @@ class VkFunction(object):
             body += "    return params.result;\n"
         return body

-    def body(self, conv, params_prefix=""):
+    def body(self, conv, conversions, params_prefix=""):
         body = ""
         needs_alloc = False
         deferred_op = None
@@ -857,7 +845,7 @@ class VkFunction(object):
         unwrap = self.name not in MANUAL_UNIX_THUNKS
         for p in self.params:
             if p.needs_conversion(conv, self.unwrap, Direction.INPUT):
-                body += p.copy(Direction.INPUT, conv, self.unwrap, prefix=params_prefix)
+                body += p.copy(Direction.INPUT, conv, self.unwrap, conversions, prefix=params_prefix)
             elif p.is_dynamic_array() and p.needs_conversion(conv, self.unwrap, Direction.OUTPUT):
                 body += "    {0}_host = ({2}{0} && {1}) ? conversion_context_alloc(ctx, sizeof(*{0}_host) * {1}) : NULL;\n".format(
                     p.name, p.get_dyn_array_len(params_prefix, conv), params_prefix)
@@ -888,7 +876,7 @@ class VkFunction(object):
         # Call any host_to_win conversion calls.
         for p in self.params:
             if p.needs_conversion(conv, self.unwrap, Direction.OUTPUT):
-                body += p.copy(Direction.OUTPUT, conv, self.unwrap, prefix=params_prefix)
+                body += p.copy(Direction.OUTPUT, conv, self.unwrap, conversions, prefix=params_prefix)

if needs_alloc:
             if deferred_op is not None:
@@ -938,7 +926,7 @@ class VkFunction(object):
         stub += "}\n\n"
         return stub

-    def thunk(self, prefix=None, conv=False):
+    def thunk(self, conversions, prefix=None, conv=False):
         thunk = ""
         if not conv:
             thunk += "#ifdef _WIN64\n"
@@ -959,7 +947,7 @@ class VkFunction(object):
             thunk += "    } *params = args;\n"
         else:
             thunk += "    struct {0}_params *params = args;\n".format(self.name)
-        thunk += self.body(conv, params_prefix="params->")
+        thunk += self.body(conv, conversions, params_prefix="params->")
         thunk += "}\n"
         if not conv:
             thunk += "#endif /* _WIN64 */\n"
@@ -1307,39 +1295,6 @@ class VkVariable(object):
     def needs_win32_type(self):
         return (self.is_struct() or (self.is_union() and self.selector)) and self.struct.needs_win32_type()

-    def get_conversions(self, unwrap, parent_const=False):
-        """ Get a list of conversions required for this parameter if any.
-        Parameters which are structures may require conversion between win32
-        and the host platform. This function returns a list of conversions
-        required.
-        """
-
-        conversions = []
-
-        # Collect any member conversions first, so we can guarantee
-        # those functions will be defined prior to usage by the
-        # 'parent' param requiring conversion.
-        if self.is_struct() or (self.is_union() and self.selector):
-            struct = self.struct
-            is_const = self.is_const() if self.is_pointer() else parent_const
-
-            conversions.extend(struct.get_conversions(unwrap, is_const))
-
-            for conv in [False, True]:
-                if struct.needs_conversion(conv, unwrap, Direction.INPUT, is_const):
-                    conversions.append(StructConversionFunction(struct, Direction.INPUT, conv, unwrap, is_const))
-                if struct.needs_conversion(conv, unwrap, Direction.OUTPUT, is_const):
-                    conversions.append(StructConversionFunction(struct, Direction.OUTPUT, conv, unwrap, is_const))
-
-        if self.is_static_array() or self.is_dynamic_array():
-            for conv in [False, True]:
-                if self.needs_conversion(conv, unwrap, Direction.INPUT, parent_const):
-                    conversions.append(ArrayConversionFunction(self, Direction.INPUT, conv, unwrap))
-                if self.needs_conversion(conv, unwrap, Direction.OUTPUT, parent_const):
-                    conversions.append(ArrayConversionFunction(self, Direction.OUTPUT, conv, unwrap))
-
-        return conversions
-
     def needs_ptr32_type(self):
         """ Check if variable needs to use PTR32 type. """

@@ -1453,18 +1408,20 @@ class VkMember(VkVariable):
                         values=values, object_type=object_type, bit_width=bit_width, returnedonly=returnedonly,
                         parent=parent, selection=selection, selector=selector)

-    def copy(self, input, output, direction, conv, unwrap):
+    def copy(self, input, output, direction, conv, unwrap, parent_const, conversions):
         """ Helper method for use by conversion logic to generate a C-code statement to copy this member.
             - `conv` indicates whether the statement is in a struct alignment conversion path. """

win_type = "win32" if conv else "win64"
         suffix = convert_suffix(direction, win_type, unwrap, self.is_wrapped())
+        is_const = self.is_const() if self.is_pointer() else parent_const

if self.needs_conversion(conv, unwrap, direction, False):
             if self.is_dynamic_array():
                 # Array length is either a variable name (string) or an int.
                 count = self.get_dyn_array_len(input, conv)
                 pointer_part = "pointer_" if self.pointer_array else ""
+                conversions.append(ArrayConversionFunction(self, direction, conv, unwrap))
                 if direction == Direction.OUTPUT:
                     return "convert_{2}_{6}array_{5}({3}{1}, {0}, {4});\n".format(self.value(output, conv),
                         self.name, self.type, input, count, suffix, pointer_part)
@@ -1477,6 +1434,7 @@ class VkMember(VkVariable):
                     LOGGER.warn("TODO: implement conversion of multidimensional static array for {0}.{1}".format(self.type, self.name))
                 elif direction == Direction.OUTPUT:
                     # Needed by VkMemoryHeap.memoryHeaps
+                    conversions.append(ArrayConversionFunction(self, direction, conv, unwrap))
                     return "convert_{0}_array_{5}({2}{1}, {3}{1}, {4});\n".format(self.type,
                         self.name, input, output, count, suffix)
                 else:
@@ -1498,6 +1456,7 @@ class VkMember(VkVariable):
                 return "{0}{1} = wine_vk_unwrap_handle({2}{3}, {2}{1});\n".format(output, self.name, input, self.object_type)
             else:
                 selector_part = ", {0}{1}".format(input, self.selector) if self.selector else ""
+                conversions.append(StructConversionFunction(self.struct, direction, conv, unwrap, is_const))
                 if direction == Direction.OUTPUT:
                     return "convert_{0}_{4}(&{2}{1}, &{3}{1}{5});\n".format(self.type,
                         self.name, input, output, suffix, selector_part)
@@ -1714,16 +1673,19 @@ class VkParam(VkVariable):
             else:
                 LOGGER.warn("Unhandled type: {0}".format(self.type_info))

-    def copy(self, direction, conv, unwrap, prefix=""):
+    def copy(self, direction, conv, unwrap, conversions, prefix=""):
         win_type = "win32" if conv else "win64"
         suffix = convert_suffix(direction, win_type, unwrap, self.is_wrapped())
+        is_const = self.is_const() if self.is_pointer() else False

if direction == Direction.INPUT:
             ctx_param = "ctx, " if self.needs_alloc(conv, unwrap) else ""
             if self.is_dynamic_array():
+                conversions.append(ArrayConversionFunction(self, direction, conv, unwrap))
                 return "    {0}_host = convert_{2}_array_{4}({5}{1}, {3});\n".format(self.name, self.value(prefix, conv),
                     self.type, self.get_dyn_array_len(prefix, conv), suffix, ctx_param)
             elif self.optional:
+                conversions.append(StructConversionFunction(self.struct, direction, conv, unwrap, is_const))
                 ret  = "    if ({0}{1})\n".format(prefix, self.name)
                 ret += "    {\n"
                 ret += "        {0}_host = conversion_context_alloc(ctx, sizeof(*{0}_host));\n".format(self.name)
@@ -1732,6 +1694,7 @@ class VkParam(VkVariable):
                 ret += "    }\n"
                 return ret
             elif self.is_struct():
+                conversions.append(StructConversionFunction(self.struct, direction, conv, unwrap, is_const))
                 return "    convert_{0}_{3}({4}{1}, &{2}_host);\n".format(self.type, self.value(prefix, conv),
                     self.name, suffix, ctx_param)
             elif self.is_pointer_size() and self.type != "size_t":
@@ -1740,11 +1703,13 @@ class VkParam(VkVariable):
                 return "    {0}_host = *{1};\n".format(self.name, self.value(prefix, conv))
         else:
             if self.is_dynamic_array():
+                conversions.append(ArrayConversionFunction(self, direction, conv, unwrap))
                 return "    convert_{0}_array_{1}({2}_host, {3}, {4});\n".format(
                     self.type, suffix, self.name, self.value(prefix, conv).replace('const ', ''),
                     self.get_dyn_array_len(prefix, conv))
             elif self.is_struct():
                 ref_part = "" if self.optional else "&"
+                conversions.append(StructConversionFunction(self.struct, direction, conv, unwrap, is_const))
                 return "    convert_{0}_host_to_{3}({4}{2}_host, {1});\n".format(
                     self.type, self.value(prefix, conv), self.name, win_type, ref_part)
             elif self.is_pointer_size() and self.type != "size_t":
@@ -2179,23 +2144,6 @@ class VkStruct(Sequence):
             type_info = types[m.type]
             m.set_type_info(type_info)

-    def get_conversions(self, unwrap, parent_const):
-        conversions = []
-
-        # Collect any conversion for any extension structs.
-        for e in self.struct_extensions:
-            if not e.required:
-                continue
-            conversions.extend(e.get_conversions(Unwrap.HOST, parent_const))
-
-        # Collect any conversion for any member structs.
-        for m in self:
-            if m.type == self.name:
-                continue
-            conversions.extend(m.get_conversions(unwrap, parent_const))
-
-        return conversions
-

class StructConversionFunction(object):
     def __init__(self, struct, direction, conv, unwrap, const):
@@ -2230,7 +2178,7 @@ class StructConversionFunction(object):
                 return False
         return True

-    def definition(self):
+    def definition(self, conversions):
         """ Helper function for generating a struct conversion function. """

# It doesn't make sense to generate conversion functions for non-struct variables
@@ -2251,7 +2199,7 @@ class StructConversionFunction(object):
             win_type = "const " + win_type

if self.conv:
-            body += "static inline void {0}(".format(self.name)
+            body += "static void {0}(".format(self.name)

if self.direction == Direction.OUTPUT:
                 params = ["const {0} *in".format(self.type), "{0} *out".format(win_type)]
@@ -2268,7 +2216,7 @@ class StructConversionFunction(object):
             body += ")\n"

else:
-            body += "static inline void {0}(".format(self.name)
+            body += "static void {0}(".format(self.name)

params = ["const {0} *in".format(self.type), "{0} *out".format(self.type)]

@@ -2312,7 +2260,7 @@ class StructConversionFunction(object):
                 body += " || ".join("selector == {}".format(s) for s in m.selection)
                 body += ")\n    "

-            body += "    " + m.copy("in->", "out->", self.direction, self.conv, self.unwrap)
+            body += "    " + m.copy("in->", "out->", self.direction, self.conv, self.unwrap, self.const, conversions)

if needs_extensions:
             if self.conv and self.direction == Direction.INPUT:
@@ -2366,7 +2314,7 @@ class StructConversionFunction(object):
                     if m.name == "pNext":
                         copy_body += ident + "out_ext->pNext = NULL;\n"
                         continue
-                    copy_body += ident + m.copy("in_ext->", "out_ext->", self.direction, self.conv, Unwrap.HOST)
+                    copy_body += ident + m.copy("in_ext->", "out_ext->", self.direction, self.conv, Unwrap.HOST, self.const, conversions)

# Generate the definition of "in_ext" if we need it
                 if "in_ext->" in copy_body:
@@ -2419,7 +2367,7 @@ class ArrayConversionFunction(object):
     def __eq__(self, other):
         return self.name == other.name

-    def definition(self):
+    def definition(self, conversions):
         """ Helper function for generating a conversion function for array operands. """

body = ""
@@ -2459,10 +2407,10 @@ class ArrayConversionFunction(object):

# Generate function prototype.
         if return_type:
-            body += "static inline {0}{1} {2}{3}(".format(
+            body += "static {0}{1} {2}{3}(".format(
                 "const " if self.array.is_const() else "", return_type, pointer_part, self.name)
         else:
-            body += "static inline void {0}(".format(self.name)
+            body += "static void {0}(".format(self.name)
         if needs_alloc:
             body += "struct conversion_context *ctx, "
         body += ", ".join(p for p in params)
@@ -2488,6 +2436,7 @@ class ArrayConversionFunction(object):

if self.array.is_struct():
                 struct = self.array.struct
+                is_const = self.array.is_const() if self.array.is_pointer() else False
                 win_part = "win32" if self.conv else "win64"
                 suffix = convert_suffix(self.direction, win_part, self.unwrap, struct.is_wrapped())
                 ctx_part = ""
@@ -2495,6 +2444,7 @@ class ArrayConversionFunction(object):
                     ctx_part = "ctx, "

if not pointer_array:
+                    conversions.append(StructConversionFunction(struct, self.direction, self.conv, self.unwrap, is_const))
                     body += "        convert_{0}_{1}({2}&in[i], &out[i]);\n".format(
                         struct.name, suffix, ctx_part)
                 else:
@@ -2506,6 +2456,7 @@ class ArrayConversionFunction(object):
                             in_param = "({0} *)UlongToPtr(in[i])".format(win_type)
                         else:
                             in_param = "in[i]"
+                        conversions.append(StructConversionFunction(struct, self.direction, self.conv, self.unwrap, is_const))
                         body += "            convert_{0}_{1}({2}{3}, out[i]);\n".format(
                             struct.name, suffix, ctx_part, in_param)
                         body += "        }\n"
@@ -2559,32 +2510,6 @@ class VkGenerator(object):
         # Build a list conversion functions for struct conversion.
         self.conversions = []
         self.win32_structs = []
-        for func in self.registry.funcs.values():
-            if not func.needs_exposing():
-                continue
-
-            conversions = func.get_conversions()
-            for conv in conversions:
-                # Append if we don't already have this conversion.
-                if not any(c == conv for c in self.conversions):
-                    self.conversions.append(conv)
-
-                if not isinstance(conv, StructConversionFunction):
-                    continue
-
-                for e in conv.operand.struct_extensions:
-                    if not e.required or not e.needs_win32_type():
-                        continue
-                    if not any(s.name == e.name for s in self.win32_structs):
-                        self.win32_structs.append(e)
-
-                if not conv.operand.needs_win32_type():
-                    continue
-
-                # Structs can be used in different ways by different conversions
-                # e.g. array vs non-array. Just make sure we pull in each struct once.
-                if not any(s.name == conv.operand.name for s in self.win32_structs):
-                    self.win32_structs.append(conv.operand)

def _generate_copyright(self, f, spec_file=False):
         f.write("# " if spec_file else "/* ")
@@ -2614,10 +2539,44 @@ class VkGenerator(object):

f.write("WINE_DEFAULT_DEBUG_CHANNEL(vulkan);\n\n")

+        # Create thunks for instance and device functions.
+        # Global functions don't go through the thunks.
+        thunks = ""
+        conversions = []
+        for vk_func in self.registry.funcs.values():
+            if not vk_func.needs_exposing():
+                continue
+            if vk_func.name in MANUAL_LOADER_FUNCTIONS:
+                continue
+
+            thunks += vk_func.thunk(conversions, prefix="thunk64_")
+            thunks += vk_func.thunk(conversions, prefix="thunk32_", conv=True)
+
         def unique(list, key=lambda x: x, seen=set()):
             return (e for e in list if not (key(e) in seen or seen.add(key(e))))

-        win32_structs = sorted(self.win32_structs, key=lambda struct: (-struct.order, struct.name))
+        def enum_conversions(conversions, visited=set()):
+            for conversion in unique(conversions, key=lambda conv: conv.name):
+                dependencies = []
+                definition = conversion.definition(dependencies)
+                yield from enum_conversions(dependencies, visited)
+                yield definition, conversion
+
+        conv_helpers = ""
+        win32_structs = []
+        for definition, conversion in enum_conversions(conversions):
+            if isinstance(conversion, StructConversionFunction):
+                for e in conversion.operand.struct_extensions:
+                    if not e.required or not e.needs_win32_type():
+                        continue
+                    win32_structs.append(e)
+                if conversion.operand.needs_win32_type():
+                    # Structs can be used in different ways by different conversions
+                    # e.g. array vs non-array. Just make sure we pull in each struct once.
+                    win32_structs.append(conversion.operand)
+            conv_helpers += definition
+
+        win32_structs = sorted(win32_structs, key=lambda struct: (-struct.order, struct.name))
         for struct in unique(win32_structs, key=lambda struct: struct.name):
             f.write(struct.definition(conv=True, align=True))
             f.write("\n")
@@ -2642,20 +2601,8 @@ class VkGenerator(object):
         f.write("    }\n")
         f.write("}\n\n")

-        # Generate any conversion helper functions.
-        for conv in self.conversions:
-            f.write(conv.definition())
-
-        # Create thunks for instance and device functions.
-        # Global functions don't go through the thunks.
-        for vk_func in self.registry.funcs.values():
-            if not vk_func.needs_exposing():
-                continue
-            if vk_func.name in MANUAL_LOADER_FUNCTIONS:
-                continue
-
-            f.write(vk_func.thunk(prefix="thunk64_"))
-            f.write(vk_func.thunk(prefix="thunk32_", conv=True))
+        f.write(conv_helpers)
+        f.write(thunks)

# Create array of device extensions.
         f.write("static const char * const vk_device_extensions[] =\n{\n")
diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index dfd1d57e7d6..a9d1616def4 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -9556,7 +9556,7 @@ static uint64_t wine_vk_unwrap_handle(uint32_t type, uint64_t handle)
     }
 }

-static inline void convert_VkAcquireNextImageInfoKHR_win32_to_unwrapped_host(const VkAcquireNextImageInfoKHR32 *in, VkAcquireNextImageInfoKHR *out)
+static void convert_VkAcquireNextImageInfoKHR_win32_to_unwrapped_host(const VkAcquireNextImageInfoKHR32 *in, VkAcquireNextImageInfoKHR *out)
 {
     if (!in) return;

@@ -9571,7 +9571,7 @@ static inline void convert_VkAcquireNextImageInfoKHR_win32_to_unwrapped_host(con
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host(const VkPerformanceConfigurationAcquireInfoINTEL32 *in, VkPerformanceConfigurationAcquireInfoINTEL *out)
+static void convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host(const VkPerformanceConfigurationAcquireInfoINTEL32 *in, VkPerformanceConfigurationAcquireInfoINTEL *out)
 {
     if (!in) return;

@@ -9582,7 +9582,7 @@ static inline void convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_h
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkAcquireProfilingLockInfoKHR_win32_to_host(const VkAcquireProfilingLockInfoKHR32 *in, VkAcquireProfilingLockInfoKHR *out)
+static void convert_VkAcquireProfilingLockInfoKHR_win32_to_host(const VkAcquireProfilingLockInfoKHR32 *in, VkAcquireProfilingLockInfoKHR *out)
 {
     if (!in) return;

@@ -9594,7 +9594,7 @@ static inline void convert_VkAcquireProfilingLockInfoKHR_win32_to_host(const VkA
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(const VkCommandBufferAllocateInfo32 *in, VkCommandBufferAllocateInfo *out)
+static void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(const VkCommandBufferAllocateInfo32 *in, VkCommandBufferAllocateInfo *out)
 {
     if (!in) return;

@@ -9607,7 +9607,7 @@ static inline void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(c
         FIXME("Unexpected pNext\n");
 }

-static inline VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_unwrapped_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
+static VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_unwrapped_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
 {
     VkCommandBuffer *out;
     unsigned int i;
@@ -9623,7 +9623,7 @@ static inline VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_unwrapped_
     return out;
 }

-static inline void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetAllocateInfo32 *in, VkDescriptorSetAllocateInfo *out)
+static void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetAllocateInfo32 *in, VkDescriptorSetAllocateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -9659,7 +9659,7 @@ static inline void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conv
     }
 }

-static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryAllocateInfo32 *in, VkMemoryAllocateInfo *out)
+static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryAllocateInfo32 *in, VkMemoryAllocateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -9800,7 +9800,7 @@ static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_
     }
 }

-static inline void convert_VkAntiLagPresentationInfoAMD_win32_to_host(const VkAntiLagPresentationInfoAMD32 *in, VkAntiLagPresentationInfoAMD *out)
+static void convert_VkAntiLagPresentationInfoAMD_win32_to_host(const VkAntiLagPresentationInfoAMD32 *in, VkAntiLagPresentationInfoAMD *out)
 {
     if (!in) return;

@@ -9812,7 +9812,7 @@ static inline void convert_VkAntiLagPresentationInfoAMD_win32_to_host(const VkAn
         FIXME("Unexpected pNext\n");
 }

-static inline const VkAntiLagPresentationInfoAMD *convert_VkAntiLagPresentationInfoAMD_array_win32_to_host(struct conversion_context *ctx, const VkAntiLagPresentationInfoAMD32 *in, uint32_t count)
+static const VkAntiLagPresentationInfoAMD *convert_VkAntiLagPresentationInfoAMD_array_win32_to_host(struct conversion_context *ctx, const VkAntiLagPresentationInfoAMD32 *in, uint32_t count)
 {
     VkAntiLagPresentationInfoAMD *out;
     unsigned int i;
@@ -9828,7 +9828,7 @@ static inline const VkAntiLagPresentationInfoAMD *convert_VkAntiLagPresentationI
     return out;
 }

-static inline void convert_VkAntiLagDataAMD_win32_to_host(struct conversion_context *ctx, const VkAntiLagDataAMD32 *in, VkAntiLagDataAMD *out)
+static void convert_VkAntiLagDataAMD_win32_to_host(struct conversion_context *ctx, const VkAntiLagDataAMD32 *in, VkAntiLagDataAMD *out)
 {
     if (!in) return;

@@ -9842,7 +9842,7 @@ static inline void convert_VkAntiLagDataAMD_win32_to_host(struct conversion_cont
 }

#ifdef _WIN64
-static inline void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo *in, VkCommandBufferInheritanceInfo *out)
+static void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo *in, VkCommandBufferInheritanceInfo *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -9985,7 +9985,37 @@ static inline void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct c
 }
 #endif /* _WIN64 */

-static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, VkCommandBufferInheritanceInfo *out)
+#ifdef _WIN64
+static const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo *in, uint32_t count)
+{
+    VkCommandBufferInheritanceInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkCommandBufferInheritanceInfo_win64_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+#endif /* _WIN64 */
+
+#ifdef _WIN64
+static void convert_VkCommandBufferBeginInfo_win64_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo *in, VkCommandBufferBeginInfo *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->flags = in->flags;
+    out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win64_to_host(ctx, in->pInheritanceInfo, 1);
+}
+#endif /* _WIN64 */
+
+static void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, VkCommandBufferInheritanceInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -10127,25 +10157,7 @@ static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct c
     }
 }

-#ifdef _WIN64
-static inline const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo *in, uint32_t count)
-{
-    VkCommandBufferInheritanceInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkCommandBufferInheritanceInfo_win64_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-#endif /* _WIN64 */
-
-static inline const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, uint32_t count)
+static const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, uint32_t count)
 {
     VkCommandBufferInheritanceInfo *out;
     unsigned int i;
@@ -10161,19 +10173,7 @@ static inline const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInher
     return out;
 }

-#ifdef _WIN64
-static inline void convert_VkCommandBufferBeginInfo_win64_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo *in, VkCommandBufferBeginInfo *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->flags = in->flags;
-    out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win64_to_host(ctx, in->pInheritanceInfo, 1);
-}
-#endif /* _WIN64 */
-
-static inline void convert_VkCommandBufferBeginInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo32 *in, VkCommandBufferBeginInfo *out)
+static void convert_VkCommandBufferBeginInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo32 *in, VkCommandBufferBeginInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -10208,7 +10208,7 @@ static inline void convert_VkCommandBufferBeginInfo_win32_to_host(struct convers
 }

#ifdef _WIN64
-static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win64_to_host(const VkBindAccelerationStructureMemoryInfoNV *in, VkBindAccelerationStructureMemoryInfoNV *out)
+static void convert_VkBindAccelerationStructureMemoryInfoNV_win64_to_host(const VkBindAccelerationStructureMemoryInfoNV *in, VkBindAccelerationStructureMemoryInfoNV *out)
 {
     if (!in) return;

@@ -10222,23 +10222,8 @@ static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win64_to_host
 }
 #endif /* _WIN64 */

-static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(const VkBindAccelerationStructureMemoryInfoNV32 *in, VkBindAccelerationStructureMemoryInfoNV *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->accelerationStructure = in->accelerationStructure;
-    out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory;
-    out->memoryOffset = in->memoryOffset;
-    out->deviceIndexCount = in->deviceIndexCount;
-    out->pDeviceIndices = UlongToPtr(in->pDeviceIndices);
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
-}
-
 #ifdef _WIN64
-static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV *in, uint32_t count)
+static const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV *in, uint32_t count)
 {
     VkBindAccelerationStructureMemoryInfoNV *out;
     unsigned int i;
@@ -10255,7 +10240,22 @@ static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccel
 }
 #endif /* _WIN64 */

-static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV32 *in, uint32_t count)
+static void convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(const VkBindAccelerationStructureMemoryInfoNV32 *in, VkBindAccelerationStructureMemoryInfoNV *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->accelerationStructure = in->accelerationStructure;
+    out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory;
+    out->memoryOffset = in->memoryOffset;
+    out->deviceIndexCount = in->deviceIndexCount;
+    out->pDeviceIndices = UlongToPtr(in->pDeviceIndices);
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV32 *in, uint32_t count)
 {
     VkBindAccelerationStructureMemoryInfoNV *out;
     unsigned int i;
@@ -10272,7 +10272,7 @@ static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccel
 }

#ifdef _WIN64
-static inline void convert_VkBindBufferMemoryInfo_win64_to_host(const VkBindBufferMemoryInfo *in, VkBindBufferMemoryInfo *out)
+static void convert_VkBindBufferMemoryInfo_win64_to_host(const VkBindBufferMemoryInfo *in, VkBindBufferMemoryInfo *out)
 {
     if (!in) return;

@@ -10284,7 +10284,25 @@ static inline void convert_VkBindBufferMemoryInfo_win64_to_host(const VkBindBuff
 }
 #endif /* _WIN64 */

-static inline void convert_VkBindBufferMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, VkBindBufferMemoryInfo *out)
+#ifdef _WIN64
+static const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo *in, uint32_t count)
+{
+    VkBindBufferMemoryInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkBindBufferMemoryInfo_win64_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+#endif /* _WIN64 */
+
+static void convert_VkBindBufferMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, VkBindBufferMemoryInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -10331,25 +10349,7 @@ static inline void convert_VkBindBufferMemoryInfo_win32_to_host(struct conversio
     }
 }

-#ifdef _WIN64
-static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo *in, uint32_t count)
-{
-    VkBindBufferMemoryInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkBindBufferMemoryInfo_win64_to_host(&in[i], &out[i]);
-    }
-
-    return out;
-}
-#endif /* _WIN64 */
-
-static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, uint32_t count)
+static const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, uint32_t count)
 {
     VkBindBufferMemoryInfo *out;
     unsigned int i;
@@ -10366,7 +10366,7 @@ static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array
 }

#ifdef _WIN64
-static inline void convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win64_to_host(const VkBindDataGraphPipelineSessionMemoryInfoARM *in, VkBindDataGraphPipelineSessionMemoryInfoARM *out)
+static void convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win64_to_host(const VkBindDataGraphPipelineSessionMemoryInfoARM *in, VkBindDataGraphPipelineSessionMemoryInfoARM *out)
 {
     if (!in) return;

@@ -10380,23 +10380,8 @@ static inline void convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win64_to_
 }
 #endif /* _WIN64 */

-static inline void convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win32_to_host(const VkBindDataGraphPipelineSessionMemoryInfoARM32 *in, VkBindDataGraphPipelineSessionMemoryInfoARM *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->session = in->session;
-    out->bindPoint = in->bindPoint;
-    out->objectIndex = in->objectIndex;
-    out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory;
-    out->memoryOffset = in->memoryOffset;
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
-}
-
 #ifdef _WIN64
-static inline const VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindDataGraphPipelineSessionMemoryInfoARM_array_win64_to_host(struct conversion_context *ctx, const VkBindDataGraphPipelineSessionMemoryInfoARM *in, uint32_t count)
+static const VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindDataGraphPipelineSessionMemoryInfoARM_array_win64_to_host(struct conversion_context *ctx, const VkBindDataGraphPipelineSessionMemoryInfoARM *in, uint32_t count)
 {
     VkBindDataGraphPipelineSessionMemoryInfoARM *out;
     unsigned int i;
@@ -10413,7 +10398,22 @@ static inline const VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindD
 }
 #endif /* _WIN64 */

-static inline const VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindDataGraphPipelineSessionMemoryInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkBindDataGraphPipelineSessionMemoryInfoARM32 *in, uint32_t count)
+static void convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win32_to_host(const VkBindDataGraphPipelineSessionMemoryInfoARM32 *in, VkBindDataGraphPipelineSessionMemoryInfoARM *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->session = in->session;
+    out->bindPoint = in->bindPoint;
+    out->objectIndex = in->objectIndex;
+    out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory;
+    out->memoryOffset = in->memoryOffset;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static const VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindDataGraphPipelineSessionMemoryInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkBindDataGraphPipelineSessionMemoryInfoARM32 *in, uint32_t count)
 {
     VkBindDataGraphPipelineSessionMemoryInfoARM *out;
     unsigned int i;
@@ -10430,7 +10430,7 @@ static inline const VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindD
 }

#ifdef _WIN64
-static inline void convert_VkBindImageMemoryInfo_win64_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo *in, VkBindImageMemoryInfo *out)
+static void convert_VkBindImageMemoryInfo_win64_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo *in, VkBindImageMemoryInfo *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -10503,7 +10503,25 @@ static inline void convert_VkBindImageMemoryInfo_win64_to_host(struct conversion
 }
 #endif /* _WIN64 */

-static inline void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, VkBindImageMemoryInfo *out)
+#ifdef _WIN64
+static const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo *in, uint32_t count)
+{
+    VkBindImageMemoryInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkBindImageMemoryInfo_win64_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+#endif /* _WIN64 */
+
+static void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, VkBindImageMemoryInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -10575,25 +10593,7 @@ static inline void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion
     }
 }

-#ifdef _WIN64
-static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo *in, uint32_t count)
-{
-    VkBindImageMemoryInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkBindImageMemoryInfo_win64_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-#endif /* _WIN64 */
-
-static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, uint32_t count)
+static const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, uint32_t count)
 {
     VkBindImageMemoryInfo *out;
     unsigned int i;
@@ -10610,7 +10610,7 @@ static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_w
 }

#ifdef _WIN64
-static inline void convert_VkBindTensorMemoryInfoARM_win64_to_host(const VkBindTensorMemoryInfoARM *in, VkBindTensorMemoryInfoARM *out)
+static void convert_VkBindTensorMemoryInfoARM_win64_to_host(const VkBindTensorMemoryInfoARM *in, VkBindTensorMemoryInfoARM *out)
 {
     if (!in) return;

@@ -10622,21 +10622,8 @@ static inline void convert_VkBindTensorMemoryInfoARM_win64_to_host(const VkBindT
 }
 #endif /* _WIN64 */

-static inline void convert_VkBindTensorMemoryInfoARM_win32_to_host(const VkBindTensorMemoryInfoARM32 *in, VkBindTensorMemoryInfoARM *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->tensor = in->tensor;
-    out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory;
-    out->memoryOffset = in->memoryOffset;
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
-}
-
 #ifdef _WIN64
-static inline const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM_array_win64_to_host(struct conversion_context *ctx, const VkBindTensorMemoryInfoARM *in, uint32_t count)
+static const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM_array_win64_to_host(struct conversion_context *ctx, const VkBindTensorMemoryInfoARM *in, uint32_t count)
 {
     VkBindTensorMemoryInfoARM *out;
     unsigned int i;
@@ -10653,7 +10640,20 @@ static inline const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM
 }
 #endif /* _WIN64 */

-static inline const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkBindTensorMemoryInfoARM32 *in, uint32_t count)
+static void convert_VkBindTensorMemoryInfoARM_win32_to_host(const VkBindTensorMemoryInfoARM32 *in, VkBindTensorMemoryInfoARM *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->tensor = in->tensor;
+    out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory;
+    out->memoryOffset = in->memoryOffset;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkBindTensorMemoryInfoARM32 *in, uint32_t count)
 {
     VkBindTensorMemoryInfoARM *out;
     unsigned int i;
@@ -10670,7 +10670,7 @@ static inline const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM
 }

#ifdef _WIN64
-static inline void convert_VkBindVideoSessionMemoryInfoKHR_win64_to_host(const VkBindVideoSessionMemoryInfoKHR *in, VkBindVideoSessionMemoryInfoKHR *out)
+static void convert_VkBindVideoSessionMemoryInfoKHR_win64_to_host(const VkBindVideoSessionMemoryInfoKHR *in, VkBindVideoSessionMemoryInfoKHR *out)
 {
     if (!in) return;

@@ -10683,22 +10683,8 @@ static inline void convert_VkBindVideoSessionMemoryInfoKHR_win64_to_host(const V
 }
 #endif /* _WIN64 */

-static inline void convert_VkBindVideoSessionMemoryInfoKHR_win32_to_host(const VkBindVideoSessionMemoryInfoKHR32 *in, VkBindVideoSessionMemoryInfoKHR *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->memoryBindIndex = in->memoryBindIndex;
-    out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory;
-    out->memoryOffset = in->memoryOffset;
-    out->memorySize = in->memorySize;
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
-}
-
 #ifdef _WIN64
-static inline const VkBindVideoSessionMemoryInfoKHR *convert_VkBindVideoSessionMemoryInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkBindVideoSessionMemoryInfoKHR *in, uint32_t count)
+static const VkBindVideoSessionMemoryInfoKHR *convert_VkBindVideoSessionMemoryInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkBindVideoSessionMemoryInfoKHR *in, uint32_t count)
 {
     VkBindVideoSessionMemoryInfoKHR *out;
     unsigned int i;
@@ -10715,7 +10701,21 @@ static inline const VkBindVideoSessionMemoryInfoKHR *convert_VkBindVideoSessionM
 }
 #endif /* _WIN64 */

-static inline const VkBindVideoSessionMemoryInfoKHR *convert_VkBindVideoSessionMemoryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkBindVideoSessionMemoryInfoKHR32 *in, uint32_t count)
+static void convert_VkBindVideoSessionMemoryInfoKHR_win32_to_host(const VkBindVideoSessionMemoryInfoKHR32 *in, VkBindVideoSessionMemoryInfoKHR *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->memoryBindIndex = in->memoryBindIndex;
+    out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory;
+    out->memoryOffset = in->memoryOffset;
+    out->memorySize = in->memorySize;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static const VkBindVideoSessionMemoryInfoKHR *convert_VkBindVideoSessionMemoryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkBindVideoSessionMemoryInfoKHR32 *in, uint32_t count)
 {
     VkBindVideoSessionMemoryInfoKHR *out;
     unsigned int i;
@@ -10731,7 +10731,7 @@ static inline const VkBindVideoSessionMemoryInfoKHR *convert_VkBindVideoSessionM
     return out;
 }

-static inline const VkMicromapUsageEXT * const*convert_VkMicromapUsageEXT_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
+static const VkMicromapUsageEXT * const*convert_VkMicromapUsageEXT_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
 {
     VkMicromapUsageEXT **out;
     unsigned int i;
@@ -10747,7 +10747,7 @@ static inline const VkMicromapUsageEXT * const*convert_VkMicromapUsageEXT_pointe
     return (void *)out;
 }

-static inline void convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryTrianglesDataKHR32 *in, VkAccelerationStructureGeometryTrianglesDataKHR *out)
+static void convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryTrianglesDataKHR32 *in, VkAccelerationStructureGeometryTrianglesDataKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -10804,7 +10804,7 @@ static inline void convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32
     }
 }

-static inline void convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(const VkAccelerationStructureGeometryAabbsDataKHR32 *in, VkAccelerationStructureGeometryAabbsDataKHR *out)
+static void convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(const VkAccelerationStructureGeometryAabbsDataKHR32 *in, VkAccelerationStructureGeometryAabbsDataKHR *out)
 {
     if (!in) return;

@@ -10816,7 +10816,7 @@ static inline void convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(const VkAccelerationStructureGeometryInstancesDataKHR32 *in, VkAccelerationStructureGeometryInstancesDataKHR *out)
+static void convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(const VkAccelerationStructureGeometryInstancesDataKHR32 *in, VkAccelerationStructureGeometryInstancesDataKHR *out)
 {
     if (!in) return;

@@ -10828,7 +10828,7 @@ static inline void convert_VkAccelerationStructureGeometryInstancesDataKHR_win32
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryDataKHR32 *in, VkAccelerationStructureGeometryDataKHR *out, VkFlags selector)
+static void convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryDataKHR32 *in, VkAccelerationStructureGeometryDataKHR *out, VkFlags selector)
 {
     if (!in) return;

@@ -10840,7 +10840,7 @@ static inline void convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(
         convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(&in->instances, &out->instances);
 }

-static inline void convert_VkAccelerationStructureGeometryKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, VkAccelerationStructureGeometryKHR *out)
+static void convert_VkAccelerationStructureGeometryKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, VkAccelerationStructureGeometryKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -10904,7 +10904,7 @@ static inline void convert_VkAccelerationStructureGeometryKHR_win32_to_host(stru
     }
 }

-static inline const VkAccelerationStructureGeometryKHR *convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, uint32_t count)
+static const VkAccelerationStructureGeometryKHR *convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, uint32_t count)
 {
     VkAccelerationStructureGeometryKHR *out;
     unsigned int i;
@@ -10920,7 +10920,7 @@ static inline const VkAccelerationStructureGeometryKHR *convert_VkAccelerationSt
     return out;
 }

-static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
+static const VkAccelerationStructureGeometryKHR * const*convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
 {
     VkAccelerationStructureGeometryKHR **out;
     unsigned int i;
@@ -10942,7 +10942,7 @@ static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAcceler
     return (void *)out;
 }

-static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, VkAccelerationStructureBuildGeometryInfoKHR *out)
+static void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, VkAccelerationStructureBuildGeometryInfoKHR *out)
 {
     if (!in) return;

@@ -10961,7 +10961,7 @@ static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_
         FIXME("Unexpected pNext\n");
 }

-static inline const VkAccelerationStructureBuildGeometryInfoKHR *convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, uint32_t count)
+static const VkAccelerationStructureBuildGeometryInfoKHR *convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, uint32_t count)
 {
     VkAccelerationStructureBuildGeometryInfoKHR *out;
     unsigned int i;
@@ -10977,7 +10977,7 @@ static inline const VkAccelerationStructureBuildGeometryInfoKHR *convert_VkAccel
     return out;
 }

-static inline const VkAccelerationStructureBuildRangeInfoKHR * const*convert_VkAccelerationStructureBuildRangeInfoKHR_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
+static const VkAccelerationStructureBuildRangeInfoKHR * const*convert_VkAccelerationStructureBuildRangeInfoKHR_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
 {
     VkAccelerationStructureBuildRangeInfoKHR **out;
     unsigned int i;
@@ -10993,7 +10993,7 @@ static inline const VkAccelerationStructureBuildRangeInfoKHR * const*convert_VkA
     return (void *)out;
 }

-static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, VkMicromapBuildInfoEXT *out)
+static void convert_VkMicromapBuildInfoEXT_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, VkMicromapBuildInfoEXT *out)
 {
     if (!in) return;

@@ -11014,7 +11014,7 @@ static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(struct conversio
         FIXME("Unexpected pNext\n");
 }

-static inline const VkMicromapBuildInfoEXT *convert_VkMicromapBuildInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, uint32_t count)
+static const VkMicromapBuildInfoEXT *convert_VkMicromapBuildInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, uint32_t count)
 {
     VkMicromapBuildInfoEXT *out;
     unsigned int i;
@@ -11030,7 +11030,7 @@ static inline const VkMicromapBuildInfoEXT *convert_VkMicromapBuildInfoEXT_array
     return out;
 }

-static inline void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(const VkConditionalRenderingBeginInfoEXT32 *in, VkConditionalRenderingBeginInfoEXT *out)
+static void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(const VkConditionalRenderingBeginInfoEXT32 *in, VkConditionalRenderingBeginInfoEXT *out)
 {
     if (!in) return;

@@ -11043,7 +11043,7 @@ static inline void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(cons
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDebugUtilsLabelEXT_win32_to_host(const VkDebugUtilsLabelEXT32 *in, VkDebugUtilsLabelEXT *out)
+static void convert_VkDebugUtilsLabelEXT_win32_to_host(const VkDebugUtilsLabelEXT32 *in, VkDebugUtilsLabelEXT *out)
 {
     if (!in) return;

@@ -11055,7 +11055,7 @@ static inline void convert_VkDebugUtilsLabelEXT_win32_to_host(const VkDebugUtils
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPerTileBeginInfoQCOM_win32_to_host(const VkPerTileBeginInfoQCOM32 *in, VkPerTileBeginInfoQCOM *out)
+static void convert_VkPerTileBeginInfoQCOM_win32_to_host(const VkPerTileBeginInfoQCOM32 *in, VkPerTileBeginInfoQCOM *out)
 {
     if (!in) return;

@@ -11065,7 +11065,7 @@ static inline void convert_VkPerTileBeginInfoQCOM_win32_to_host(const VkPerTileB
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkSampleLocationsInfoEXT_win32_to_host(const VkSampleLocationsInfoEXT32 *in, VkSampleLocationsInfoEXT *out)
+static void convert_VkSampleLocationsInfoEXT_win32_to_host(const VkSampleLocationsInfoEXT32 *in, VkSampleLocationsInfoEXT *out)
 {
     if (!in) return;

@@ -11079,7 +11079,7 @@ static inline void convert_VkSampleLocationsInfoEXT_win32_to_host(const VkSample
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkAttachmentSampleLocationsEXT_win32_to_host(const VkAttachmentSampleLocationsEXT32 *in, VkAttachmentSampleLocationsEXT *out)
+static void convert_VkAttachmentSampleLocationsEXT_win32_to_host(const VkAttachmentSampleLocationsEXT32 *in, VkAttachmentSampleLocationsEXT *out)
 {
     if (!in) return;

@@ -11087,7 +11087,7 @@ static inline void convert_VkAttachmentSampleLocationsEXT_win32_to_host(const Vk
     convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo);
 }

-static inline const VkAttachmentSampleLocationsEXT *convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentSampleLocationsEXT32 *in, uint32_t count)
+static const VkAttachmentSampleLocationsEXT *convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentSampleLocationsEXT32 *in, uint32_t count)
 {
     VkAttachmentSampleLocationsEXT *out;
     unsigned int i;
@@ -11103,7 +11103,7 @@ static inline const VkAttachmentSampleLocationsEXT *convert_VkAttachmentSampleLo
     return out;
 }

-static inline void convert_VkSubpassSampleLocationsEXT_win32_to_host(const VkSubpassSampleLocationsEXT32 *in, VkSubpassSampleLocationsEXT *out)
+static void convert_VkSubpassSampleLocationsEXT_win32_to_host(const VkSubpassSampleLocationsEXT32 *in, VkSubpassSampleLocationsEXT *out)
 {
     if (!in) return;

@@ -11111,7 +11111,7 @@ static inline void convert_VkSubpassSampleLocationsEXT_win32_to_host(const VkSub
     convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo);
 }

-static inline const VkSubpassSampleLocationsEXT *convert_VkSubpassSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkSubpassSampleLocationsEXT32 *in, uint32_t count)
+static const VkSubpassSampleLocationsEXT *convert_VkSubpassSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkSubpassSampleLocationsEXT32 *in, uint32_t count)
 {
     VkSubpassSampleLocationsEXT *out;
     unsigned int i;
@@ -11127,7 +11127,7 @@ static inline const VkSubpassSampleLocationsEXT *convert_VkSubpassSampleLocation
     return out;
 }

-static inline void convert_VkRenderPassStripeInfoARM_win32_to_host(const VkRenderPassStripeInfoARM32 *in, VkRenderPassStripeInfoARM *out)
+static void convert_VkRenderPassStripeInfoARM_win32_to_host(const VkRenderPassStripeInfoARM32 *in, VkRenderPassStripeInfoARM *out)
 {
     if (!in) return;

@@ -11138,7 +11138,7 @@ static inline void convert_VkRenderPassStripeInfoARM_win32_to_host(const VkRende
         FIXME("Unexpected pNext\n");
 }

-static inline const VkRenderPassStripeInfoARM *convert_VkRenderPassStripeInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkRenderPassStripeInfoARM32 *in, uint32_t count)
+static const VkRenderPassStripeInfoARM *convert_VkRenderPassStripeInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkRenderPassStripeInfoARM32 *in, uint32_t count)
 {
     VkRenderPassStripeInfoARM *out;
     unsigned int i;
@@ -11154,7 +11154,7 @@ static inline const VkRenderPassStripeInfoARM *convert_VkRenderPassStripeInfoARM
     return out;
 }

-static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassBeginInfo32 *in, VkRenderPassBeginInfo *out)
+static void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassBeginInfo32 *in, VkRenderPassBeginInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -11254,7 +11254,7 @@ static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion
     }
 }

-static inline void convert_VkSubpassBeginInfo_win32_to_host(const VkSubpassBeginInfo32 *in, VkSubpassBeginInfo *out)
+static void convert_VkSubpassBeginInfo_win32_to_host(const VkSubpassBeginInfo32 *in, VkSubpassBeginInfo *out)
 {
     if (!in) return;

@@ -11265,7 +11265,7 @@ static inline void convert_VkSubpassBeginInfo_win32_to_host(const VkSubpassBegin
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkRenderingAttachmentInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, VkRenderingAttachmentInfo *out)
+static void convert_VkRenderingAttachmentInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, VkRenderingAttachmentInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -11305,7 +11305,7 @@ static inline void convert_VkRenderingAttachmentInfo_win32_to_host(struct conver
     }
 }

-static inline const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo_array_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, uint32_t count)
+static const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo_array_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, uint32_t count)
 {
     VkRenderingAttachmentInfo *out;
     unsigned int i;
@@ -11321,7 +11321,7 @@ static inline const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo
     return out;
 }

-static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingInfo32 *in, VkRenderingInfo *out)
+static void convert_VkRenderingInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingInfo32 *in, VkRenderingInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -11447,80 +11447,37 @@ static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_conte
     }
 }

-static inline void convert_VkVideoEncodeRateControlLayerInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeRateControlLayerInfoKHR32 *in, VkVideoEncodeRateControlLayerInfoKHR *out)
+static void convert_VkVideoPictureResourceInfoKHR_win32_to_host(const VkVideoPictureResourceInfoKHR32 *in, VkVideoPictureResourceInfoKHR *out)
 {
-    const VkBaseInStructure32 *in_header;
-    VkBaseOutStructure *out_header = (void *)out;
-
     if (!in) return;

out->sType = in->sType;
     out->pNext = NULL;
-    out->averageBitrate = in->averageBitrate;
-    out->maxBitrate = in->maxBitrate;
-    out->frameRateNumerator = in->frameRateNumerator;
-    out->frameRateDenominator = in->frameRateDenominator;
+    out->codedOffset = in->codedOffset;
+    out->codedExtent = in->codedExtent;
+    out->baseArrayLayer = in->baseArrayLayer;
+    out->imageViewBinding = in->imageViewBinding;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}

-    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+static const VkVideoPictureResourceInfoKHR *convert_VkVideoPictureResourceInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoPictureResourceInfoKHR32 *in, uint32_t count)
+{
+    VkVideoPictureResourceInfoKHR *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
     {
-        switch (in_header->sType)
-        {
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
-        {
-            VkVideoEncodeH264RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeH264RateControlLayerInfoKHR32 *in_ext = (const VkVideoEncodeH264RateControlLayerInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->useMinQp = in_ext->useMinQp;
-            out_ext->minQp = in_ext->minQp;
-            out_ext->useMaxQp = in_ext->useMaxQp;
-            out_ext->maxQp = in_ext->maxQp;
-            out_ext->useMaxFrameSize = in_ext->useMaxFrameSize;
-            out_ext->maxFrameSize = in_ext->maxFrameSize;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
-        {
-            VkVideoEncodeAV1RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeAV1RateControlLayerInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlLayerInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->useMinQIndex = in_ext->useMinQIndex;
-            out_ext->minQIndex = in_ext->minQIndex;
-            out_ext->useMaxQIndex = in_ext->useMaxQIndex;
-            out_ext->maxQIndex = in_ext->maxQIndex;
-            out_ext->useMaxFrameSize = in_ext->useMaxFrameSize;
-            out_ext->maxFrameSize = in_ext->maxFrameSize;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        default:
-            FIXME("Unhandled sType %u.\n", in_header->sType);
-            break;
-        }
-    }
-}
-
-static inline const VkVideoEncodeRateControlLayerInfoKHR *convert_VkVideoEncodeRateControlLayerInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeRateControlLayerInfoKHR32 *in, uint32_t count)
-{
-    VkVideoEncodeRateControlLayerInfoKHR *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkVideoEncodeRateControlLayerInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
+        convert_VkVideoPictureResourceInfoKHR_win32_to_host(&in[i], &out[i]);
     }

return out;
 }

-static inline void convert_StdVideoEncodeAV1ReferenceInfo_win32_to_host(const StdVideoEncodeAV1ReferenceInfo32 *in, StdVideoEncodeAV1ReferenceInfo *out)
+static void convert_StdVideoEncodeAV1ReferenceInfo_win32_to_host(const StdVideoEncodeAV1ReferenceInfo32 *in, StdVideoEncodeAV1ReferenceInfo *out)
 {
     if (!in) return;

@@ -11532,7 +11489,7 @@ static inline void convert_StdVideoEncodeAV1ReferenceInfo_win32_to_host(const St
     out->pExtensionHeader = UlongToPtr(in->pExtensionHeader);
 }

-static inline const StdVideoEncodeAV1ReferenceInfo *convert_StdVideoEncodeAV1ReferenceInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1ReferenceInfo32 *in, uint32_t count)
+static const StdVideoEncodeAV1ReferenceInfo *convert_StdVideoEncodeAV1ReferenceInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1ReferenceInfo32 *in, uint32_t count)
 {
     StdVideoEncodeAV1ReferenceInfo *out;
     unsigned int i;
@@ -11548,37 +11505,7 @@ static inline const StdVideoEncodeAV1ReferenceInfo *convert_StdVideoEncodeAV1Ref
     return out;
 }

-static inline void convert_VkVideoPictureResourceInfoKHR_win32_to_host(const VkVideoPictureResourceInfoKHR32 *in, VkVideoPictureResourceInfoKHR *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->codedOffset = in->codedOffset;
-    out->codedExtent = in->codedExtent;
-    out->baseArrayLayer = in->baseArrayLayer;
-    out->imageViewBinding = in->imageViewBinding;
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
-}
-
-static inline const VkVideoPictureResourceInfoKHR *convert_VkVideoPictureResourceInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoPictureResourceInfoKHR32 *in, uint32_t count)
-{
-    VkVideoPictureResourceInfoKHR *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkVideoPictureResourceInfoKHR_win32_to_host(&in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoReferenceSlotInfoKHR32 *in, VkVideoReferenceSlotInfoKHR *out)
+static void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoReferenceSlotInfoKHR32 *in, VkVideoReferenceSlotInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -11656,7 +11583,7 @@ static inline void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conv
     }
 }

-static inline const VkVideoReferenceSlotInfoKHR *convert_VkVideoReferenceSlotInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoReferenceSlotInfoKHR32 *in, uint32_t count)
+static const VkVideoReferenceSlotInfoKHR *convert_VkVideoReferenceSlotInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoReferenceSlotInfoKHR32 *in, uint32_t count)
 {
     VkVideoReferenceSlotInfoKHR *out;
     unsigned int i;
@@ -11672,7 +11599,80 @@ static inline const VkVideoReferenceSlotInfoKHR *convert_VkVideoReferenceSlotInf
     return out;
 }

-static inline void convert_VkVideoBeginCodingInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoBeginCodingInfoKHR32 *in, VkVideoBeginCodingInfoKHR *out)
+static void convert_VkVideoEncodeRateControlLayerInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeRateControlLayerInfoKHR32 *in, VkVideoEncodeRateControlLayerInfoKHR *out)
+{
+    const VkBaseInStructure32 *in_header;
+    VkBaseOutStructure *out_header = (void *)out;
+
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->averageBitrate = in->averageBitrate;
+    out->maxBitrate = in->maxBitrate;
+    out->frameRateNumerator = in->frameRateNumerator;
+    out->frameRateDenominator = in->frameRateDenominator;
+
+    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+    {
+        switch (in_header->sType)
+        {
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
+        {
+            VkVideoEncodeH264RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeH264RateControlLayerInfoKHR32 *in_ext = (const VkVideoEncodeH264RateControlLayerInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR;
+            out_ext->pNext = NULL;
+            out_ext->useMinQp = in_ext->useMinQp;
+            out_ext->minQp = in_ext->minQp;
+            out_ext->useMaxQp = in_ext->useMaxQp;
+            out_ext->maxQp = in_ext->maxQp;
+            out_ext->useMaxFrameSize = in_ext->useMaxFrameSize;
+            out_ext->maxFrameSize = in_ext->maxFrameSize;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
+        {
+            VkVideoEncodeAV1RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeAV1RateControlLayerInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlLayerInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR;
+            out_ext->pNext = NULL;
+            out_ext->useMinQIndex = in_ext->useMinQIndex;
+            out_ext->minQIndex = in_ext->minQIndex;
+            out_ext->useMaxQIndex = in_ext->useMaxQIndex;
+            out_ext->maxQIndex = in_ext->maxQIndex;
+            out_ext->useMaxFrameSize = in_ext->useMaxFrameSize;
+            out_ext->maxFrameSize = in_ext->maxFrameSize;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        default:
+            FIXME("Unhandled sType %u.\n", in_header->sType);
+            break;
+        }
+    }
+}
+
+static const VkVideoEncodeRateControlLayerInfoKHR *convert_VkVideoEncodeRateControlLayerInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeRateControlLayerInfoKHR32 *in, uint32_t count)
+{
+    VkVideoEncodeRateControlLayerInfoKHR *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkVideoEncodeRateControlLayerInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkVideoBeginCodingInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoBeginCodingInfoKHR32 *in, VkVideoBeginCodingInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -11772,7 +11772,7 @@ static inline void convert_VkVideoBeginCodingInfoKHR_win32_to_host(struct conver
     }
 }

-static inline void convert_VkBindDescriptorBufferEmbeddedSamplersInfoEXT_win32_to_host(struct conversion_context *ctx, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT32 *in, VkBindDescriptorBufferEmbeddedSamplersInfoEXT *out)
+static void convert_VkBindDescriptorBufferEmbeddedSamplersInfoEXT_win32_to_host(struct conversion_context *ctx, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT32 *in, VkBindDescriptorBufferEmbeddedSamplersInfoEXT *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -11811,7 +11811,7 @@ static inline void convert_VkBindDescriptorBufferEmbeddedSamplersInfoEXT_win32_t
     }
 }

-static inline void convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, VkDescriptorBufferBindingInfoEXT *out)
+static void convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, VkDescriptorBufferBindingInfoEXT *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -11856,7 +11856,7 @@ static inline void convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(struct
     }
 }

-static inline const VkDescriptorBufferBindingInfoEXT *convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, uint32_t count)
+static const VkDescriptorBufferBindingInfoEXT *convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, uint32_t count)
 {
     VkDescriptorBufferBindingInfoEXT *out;
     unsigned int i;
@@ -11872,7 +11872,7 @@ static inline const VkDescriptorBufferBindingInfoEXT *convert_VkDescriptorBuffer
     return out;
 }

-static inline void convert_VkBindDescriptorSetsInfo_win32_to_host(struct conversion_context *ctx, const VkBindDescriptorSetsInfo32 *in, VkBindDescriptorSetsInfo *out)
+static void convert_VkBindDescriptorSetsInfo_win32_to_host(struct conversion_context *ctx, const VkBindDescriptorSetsInfo32 *in, VkBindDescriptorSetsInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -11916,7 +11916,7 @@ static inline void convert_VkBindDescriptorSetsInfo_win32_to_host(struct convers
 }

#ifdef _WIN64
-static inline void convert_VkTileMemoryBindInfoQCOM_win64_to_host(const VkTileMemoryBindInfoQCOM *in, VkTileMemoryBindInfoQCOM *out)
+static void convert_VkTileMemoryBindInfoQCOM_win64_to_host(const VkTileMemoryBindInfoQCOM *in, VkTileMemoryBindInfoQCOM *out)
 {
     if (!in) return;

@@ -11926,7 +11926,7 @@ static inline void convert_VkTileMemoryBindInfoQCOM_win64_to_host(const VkTileMe
 }
 #endif /* _WIN64 */

-static inline void convert_VkTileMemoryBindInfoQCOM_win32_to_host(const VkTileMemoryBindInfoQCOM32 *in, VkTileMemoryBindInfoQCOM *out)
+static void convert_VkTileMemoryBindInfoQCOM_win32_to_host(const VkTileMemoryBindInfoQCOM32 *in, VkTileMemoryBindInfoQCOM *out)
 {
     if (!in) return;

@@ -11937,7 +11937,7 @@ static inline void convert_VkTileMemoryBindInfoQCOM_win32_to_host(const VkTileMe
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkImageBlit2_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, VkImageBlit2 *out)
+static void convert_VkImageBlit2_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, VkImageBlit2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -11973,7 +11973,7 @@ static inline void convert_VkImageBlit2_win32_to_host(struct conversion_context
     }
 }

-static inline const VkImageBlit2 *convert_VkImageBlit2_array_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, uint32_t count)
+static const VkImageBlit2 *convert_VkImageBlit2_array_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, uint32_t count)
 {
     VkImageBlit2 *out;
     unsigned int i;
@@ -11989,7 +11989,7 @@ static inline const VkImageBlit2 *convert_VkImageBlit2_array_win32_to_host(struc
     return out;
 }

-static inline void convert_VkBlitImageInfo2_win32_to_host(struct conversion_context *ctx, const VkBlitImageInfo232 *in, VkBlitImageInfo2 *out)
+static void convert_VkBlitImageInfo2_win32_to_host(struct conversion_context *ctx, const VkBlitImageInfo232 *in, VkBlitImageInfo2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -12028,7 +12028,7 @@ static inline void convert_VkBlitImageInfo2_win32_to_host(struct conversion_cont
     }
 }

-static inline void convert_VkGeometryTrianglesNV_win32_to_host(const VkGeometryTrianglesNV32 *in, VkGeometryTrianglesNV *out)
+static void convert_VkGeometryTrianglesNV_win32_to_host(const VkGeometryTrianglesNV32 *in, VkGeometryTrianglesNV *out)
 {
     if (!in) return;

@@ -12049,7 +12049,7 @@ static inline void convert_VkGeometryTrianglesNV_win32_to_host(const VkGeometryT
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkGeometryAABBNV_win32_to_host(const VkGeometryAABBNV32 *in, VkGeometryAABBNV *out)
+static void convert_VkGeometryAABBNV_win32_to_host(const VkGeometryAABBNV32 *in, VkGeometryAABBNV *out)
 {
     if (!in) return;

@@ -12063,7 +12063,7 @@ static inline void convert_VkGeometryAABBNV_win32_to_host(const VkGeometryAABBNV
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkGeometryDataNV_win32_to_host(const VkGeometryDataNV32 *in, VkGeometryDataNV *out)
+static void convert_VkGeometryDataNV_win32_to_host(const VkGeometryDataNV32 *in, VkGeometryDataNV *out)
 {
     if (!in) return;

@@ -12071,7 +12071,7 @@ static inline void convert_VkGeometryDataNV_win32_to_host(const VkGeometryDataNV
     convert_VkGeometryAABBNV_win32_to_host(&in->aabbs, &out->aabbs);
 }

-static inline void convert_VkGeometryNV_win32_to_host(const VkGeometryNV32 *in, VkGeometryNV *out)
+static void convert_VkGeometryNV_win32_to_host(const VkGeometryNV32 *in, VkGeometryNV *out)
 {
     if (!in) return;

@@ -12084,7 +12084,7 @@ static inline void convert_VkGeometryNV_win32_to_host(const VkGeometryNV32 *in,
         FIXME("Unexpected pNext\n");
 }

-static inline const VkGeometryNV *convert_VkGeometryNV_array_win32_to_host(struct conversion_context *ctx, const VkGeometryNV32 *in, uint32_t count)
+static const VkGeometryNV *convert_VkGeometryNV_array_win32_to_host(struct conversion_context *ctx, const VkGeometryNV32 *in, uint32_t count)
 {
     VkGeometryNV *out;
     unsigned int i;
@@ -12100,7 +12100,7 @@ static inline const VkGeometryNV *convert_VkGeometryNV_array_win32_to_host(struc
     return out;
 }

-static inline void convert_VkAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureInfoNV32 *in, VkAccelerationStructureInfoNV *out)
+static void convert_VkAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureInfoNV32 *in, VkAccelerationStructureInfoNV *out)
 {
     if (!in) return;

@@ -12115,7 +12115,7 @@ static inline void convert_VkAccelerationStructureInfoNV_win32_to_host(struct co
         FIXME("Unexpected pNext\n");
 }

-static inline const uint32_t * const*convert_uint32_t_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
+static const uint32_t * const*convert_uint32_t_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
 {
     uint32_t **out;
     unsigned int i;
@@ -12131,7 +12131,7 @@ static inline const uint32_t * const*convert_uint32_t_array_win32_to_host(struct
     return (void *)out;
 }

-static inline void convert_uint32_t_array_host_to_win32(const uint32_t * const*in, PTR32 *out, uint32_t count)
+static void convert_uint32_t_array_host_to_win32(const uint32_t * const*in, PTR32 *out, uint32_t count)
 {
     unsigned int i;

@@ -12143,7 +12143,7 @@ static inline void convert_uint32_t_array_host_to_win32(const uint32_t * const*i
     }
 }

-static inline void convert_VkClusterAccelerationStructureClustersBottomLevelInputNV_win32_to_host(const VkClusterAccelerationStructureClustersBottomLevelInputNV32 *in, VkClusterAccelerationStructureClustersBottomLevelInputNV *out)
+static void convert_VkClusterAccelerationStructureClustersBottomLevelInputNV_win32_to_host(const VkClusterAccelerationStructureClustersBottomLevelInputNV32 *in, VkClusterAccelerationStructureClustersBottomLevelInputNV *out)
 {
     if (!in) return;

@@ -12155,7 +12155,7 @@ static inline void convert_VkClusterAccelerationStructureClustersBottomLevelInpu
         FIXME("Unexpected pNext\n");
 }

-static inline VkClusterAccelerationStructureClustersBottomLevelInputNV *convert_VkClusterAccelerationStructureClustersBottomLevelInputNV_array_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureClustersBottomLevelInputNV32 *in, uint32_t count)
+static VkClusterAccelerationStructureClustersBottomLevelInputNV *convert_VkClusterAccelerationStructureClustersBottomLevelInputNV_array_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureClustersBottomLevelInputNV32 *in, uint32_t count)
 {
     VkClusterAccelerationStructureClustersBottomLevelInputNV *out;
     unsigned int i;
@@ -12171,7 +12171,7 @@ static inline VkClusterAccelerationStructureClustersBottomLevelInputNV *convert_
     return out;
 }

-static inline void convert_VkClusterAccelerationStructureTriangleClusterInputNV_win32_to_host(const VkClusterAccelerationStructureTriangleClusterInputNV32 *in, VkClusterAccelerationStructureTriangleClusterInputNV *out)
+static void convert_VkClusterAccelerationStructureTriangleClusterInputNV_win32_to_host(const VkClusterAccelerationStructureTriangleClusterInputNV32 *in, VkClusterAccelerationStructureTriangleClusterInputNV *out)
 {
     if (!in) return;

@@ -12189,7 +12189,7 @@ static inline void convert_VkClusterAccelerationStructureTriangleClusterInputNV_
         FIXME("Unexpected pNext\n");
 }

-static inline VkClusterAccelerationStructureTriangleClusterInputNV *convert_VkClusterAccelerationStructureTriangleClusterInputNV_array_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureTriangleClusterInputNV32 *in, uint32_t count)
+static VkClusterAccelerationStructureTriangleClusterInputNV *convert_VkClusterAccelerationStructureTriangleClusterInputNV_array_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureTriangleClusterInputNV32 *in, uint32_t count)
 {
     VkClusterAccelerationStructureTriangleClusterInputNV *out;
     unsigned int i;
@@ -12205,7 +12205,7 @@ static inline VkClusterAccelerationStructureTriangleClusterInputNV *convert_VkCl
     return out;
 }

-static inline void convert_VkClusterAccelerationStructureMoveObjectsInputNV_win32_to_host(const VkClusterAccelerationStructureMoveObjectsInputNV32 *in, VkClusterAccelerationStructureMoveObjectsInputNV *out)
+static void convert_VkClusterAccelerationStructureMoveObjectsInputNV_win32_to_host(const VkClusterAccelerationStructureMoveObjectsInputNV32 *in, VkClusterAccelerationStructureMoveObjectsInputNV *out)
 {
     if (!in) return;

@@ -12218,7 +12218,7 @@ static inline void convert_VkClusterAccelerationStructureMoveObjectsInputNV_win3
         FIXME("Unexpected pNext\n");
 }

-static inline VkClusterAccelerationStructureMoveObjectsInputNV *convert_VkClusterAccelerationStructureMoveObjectsInputNV_array_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureMoveObjectsInputNV32 *in, uint32_t count)
+static VkClusterAccelerationStructureMoveObjectsInputNV *convert_VkClusterAccelerationStructureMoveObjectsInputNV_array_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureMoveObjectsInputNV32 *in, uint32_t count)
 {
     VkClusterAccelerationStructureMoveObjectsInputNV *out;
     unsigned int i;
@@ -12234,7 +12234,7 @@ static inline VkClusterAccelerationStructureMoveObjectsInputNV *convert_VkCluste
     return out;
 }

-static inline void convert_VkClusterAccelerationStructureOpInputNV_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureOpInputNV32 *in, VkClusterAccelerationStructureOpInputNV *out, VkFlags selector)
+static void convert_VkClusterAccelerationStructureOpInputNV_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureOpInputNV32 *in, VkClusterAccelerationStructureOpInputNV *out, VkFlags selector)
 {
     if (!in) return;

@@ -12246,7 +12246,7 @@ static inline void convert_VkClusterAccelerationStructureOpInputNV_win32_to_host
         out->pMoveObjects = convert_VkClusterAccelerationStructureMoveObjectsInputNV_array_win32_to_host(ctx, (VkClusterAccelerationStructureMoveObjectsInputNV32 *)UlongToPtr(in->pMoveObjects), 1);
 }

-static inline void convert_VkClusterAccelerationStructureInputInfoNV_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureInputInfoNV32 *in, VkClusterAccelerationStructureInputInfoNV *out)
+static void convert_VkClusterAccelerationStructureInputInfoNV_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureInputInfoNV32 *in, VkClusterAccelerationStructureInputInfoNV *out)
 {
     if (!in) return;

@@ -12261,7 +12261,7 @@ static inline void convert_VkClusterAccelerationStructureInputInfoNV_win32_to_ho
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkStridedDeviceAddressRegionKHR_win32_to_host(const VkStridedDeviceAddressRegionKHR32 *in, VkStridedDeviceAddressRegionKHR *out)
+static void convert_VkStridedDeviceAddressRegionKHR_win32_to_host(const VkStridedDeviceAddressRegionKHR32 *in, VkStridedDeviceAddressRegionKHR *out)
 {
     if (!in) return;

@@ -12270,7 +12270,7 @@ static inline void convert_VkStridedDeviceAddressRegionKHR_win32_to_host(const V
     out->size = in->size;
 }

-static inline void convert_VkClusterAccelerationStructureCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureCommandsInfoNV32 *in, VkClusterAccelerationStructureCommandsInfoNV *out)
+static void convert_VkClusterAccelerationStructureCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureCommandsInfoNV32 *in, VkClusterAccelerationStructureCommandsInfoNV *out)
 {
     if (!in) return;

@@ -12288,7 +12288,7 @@ static inline void convert_VkClusterAccelerationStructureCommandsInfoNV_win32_to
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPartitionedAccelerationStructureInstancesInputNV_win32_to_host(struct conversion_context *ctx, const VkPartitionedAccelerationStructureInstancesInputNV32 *in, VkPartitionedAccelerationStructureInstancesInputNV *out)
+static void convert_VkPartitionedAccelerationStructureInstancesInputNV_win32_to_host(struct conversion_context *ctx, const VkPartitionedAccelerationStructureInstancesInputNV32 *in, VkPartitionedAccelerationStructureInstancesInputNV *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -12325,13 +12325,7 @@ static inline void convert_VkPartitionedAccelerationStructureInstancesInputNV_wi
     }
 }

-static inline void convert_VkPartitionedAccelerationStructureInstancesInputNV_host_to_win32(const VkPartitionedAccelerationStructureInstancesInputNV *in, const VkPartitionedAccelerationStructureInstancesInputNV32 *out)
-{
-    if (!in) return;
-
-}
-
-static inline void convert_VkBuildPartitionedAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkBuildPartitionedAccelerationStructureInfoNV32 *in, VkBuildPartitionedAccelerationStructureInfoNV *out)
+static void convert_VkBuildPartitionedAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkBuildPartitionedAccelerationStructureInfoNV32 *in, VkBuildPartitionedAccelerationStructureInfoNV *out)
 {
     if (!in) return;

@@ -12347,7 +12341,7 @@ static inline void convert_VkBuildPartitionedAccelerationStructureInfoNV_win32_t
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkVideoCodingControlInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoCodingControlInfoKHR32 *in, VkVideoCodingControlInfoKHR *out)
+static void convert_VkVideoCodingControlInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoCodingControlInfoKHR32 *in, VkVideoCodingControlInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -12426,7 +12420,7 @@ static inline void convert_VkVideoCodingControlInfoKHR_win32_to_host(struct conv
     }
 }

-static inline void convert_VkConvertCooperativeVectorMatrixInfoNV_win32_to_host(const VkConvertCooperativeVectorMatrixInfoNV32 *in, VkConvertCooperativeVectorMatrixInfoNV *out)
+static void convert_VkConvertCooperativeVectorMatrixInfoNV_win32_to_host(const VkConvertCooperativeVectorMatrixInfoNV32 *in, VkConvertCooperativeVectorMatrixInfoNV *out)
 {
     if (!in) return;

@@ -12448,7 +12442,7 @@ static inline void convert_VkConvertCooperativeVectorMatrixInfoNV_win32_to_host(
         FIXME("Unexpected pNext\n");
 }

-static inline const VkConvertCooperativeVectorMatrixInfoNV *convert_VkConvertCooperativeVectorMatrixInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkConvertCooperativeVectorMatrixInfoNV32 *in, uint32_t count)
+static const VkConvertCooperativeVectorMatrixInfoNV *convert_VkConvertCooperativeVectorMatrixInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkConvertCooperativeVectorMatrixInfoNV32 *in, uint32_t count)
 {
     VkConvertCooperativeVectorMatrixInfoNV *out;
     unsigned int i;
@@ -12464,7 +12458,7 @@ static inline const VkConvertCooperativeVectorMatrixInfoNV *convert_VkConvertCoo
     return out;
 }

-static inline void convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(const VkCopyAccelerationStructureInfoKHR32 *in, VkCopyAccelerationStructureInfoKHR *out)
+static void convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(const VkCopyAccelerationStructureInfoKHR32 *in, VkCopyAccelerationStructureInfoKHR *out)
 {
     if (!in) return;

@@ -12477,7 +12471,7 @@ static inline void convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(cons
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(const VkCopyAccelerationStructureToMemoryInfoKHR32 *in, VkCopyAccelerationStructureToMemoryInfoKHR *out)
+static void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(const VkCopyAccelerationStructureToMemoryInfoKHR32 *in, VkCopyAccelerationStructureToMemoryInfoKHR *out)
 {
     if (!in) return;

@@ -12490,7 +12484,7 @@ static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_h
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkBufferCopy_win32_to_host(const VkBufferCopy32 *in, VkBufferCopy *out)
+static void convert_VkBufferCopy_win32_to_host(const VkBufferCopy32 *in, VkBufferCopy *out)
 {
     if (!in) return;

@@ -12499,7 +12493,7 @@ static inline void convert_VkBufferCopy_win32_to_host(const VkBufferCopy32 *in,
     out->size = in->size;
 }

-static inline const VkBufferCopy *convert_VkBufferCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy32 *in, uint32_t count)
+static const VkBufferCopy *convert_VkBufferCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy32 *in, uint32_t count)
 {
     VkBufferCopy *out;
     unsigned int i;
@@ -12515,7 +12509,7 @@ static inline const VkBufferCopy *convert_VkBufferCopy_array_win32_to_host(struc
     return out;
 }

-static inline void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy232 *in, VkBufferCopy2 *out)
+static void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy232 *in, VkBufferCopy2 *out)
 {
     if (!in) return;

@@ -12528,7 +12522,7 @@ static inline void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy232 *in
         FIXME("Unexpected pNext\n");
 }

-static inline const VkBufferCopy2 *convert_VkBufferCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy232 *in, uint32_t count)
+static const VkBufferCopy2 *convert_VkBufferCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy232 *in, uint32_t count)
 {
     VkBufferCopy2 *out;
     unsigned int i;
@@ -12544,7 +12538,7 @@ static inline const VkBufferCopy2 *convert_VkBufferCopy2_array_win32_to_host(str
     return out;
 }

-static inline void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferInfo232 *in, VkCopyBufferInfo2 *out)
+static void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferInfo232 *in, VkCopyBufferInfo2 *out)
 {
     if (!in) return;

@@ -12558,7 +12552,7 @@ static inline void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_con
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkBufferImageCopy_win32_to_host(const VkBufferImageCopy32 *in, VkBufferImageCopy *out)
+static void convert_VkBufferImageCopy_win32_to_host(const VkBufferImageCopy32 *in, VkBufferImageCopy *out)
 {
     if (!in) return;

@@ -12570,7 +12564,7 @@ static inline void convert_VkBufferImageCopy_win32_to_host(const VkBufferImageCo
     out->imageExtent = in->imageExtent;
 }

-static inline const VkBufferImageCopy *convert_VkBufferImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy32 *in, uint32_t count)
+static const VkBufferImageCopy *convert_VkBufferImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy32 *in, uint32_t count)
 {
     VkBufferImageCopy *out;
     unsigned int i;
@@ -12586,7 +12580,7 @@ static inline const VkBufferImageCopy *convert_VkBufferImageCopy_array_win32_to_
     return out;
 }

-static inline void convert_VkBufferImageCopy2_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, VkBufferImageCopy2 *out)
+static void convert_VkBufferImageCopy2_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, VkBufferImageCopy2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -12624,7 +12618,7 @@ static inline void convert_VkBufferImageCopy2_win32_to_host(struct conversion_co
     }
 }

-static inline const VkBufferImageCopy2 *convert_VkBufferImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, uint32_t count)
+static const VkBufferImageCopy2 *convert_VkBufferImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, uint32_t count)
 {
     VkBufferImageCopy2 *out;
     unsigned int i;
@@ -12640,7 +12634,7 @@ static inline const VkBufferImageCopy2 *convert_VkBufferImageCopy2_array_win32_t
     return out;
 }

-static inline void convert_VkCopyBufferToImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferToImageInfo232 *in, VkCopyBufferToImageInfo2 *out)
+static void convert_VkCopyBufferToImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferToImageInfo232 *in, VkCopyBufferToImageInfo2 *out)
 {
     if (!in) return;

@@ -12655,7 +12649,7 @@ static inline void convert_VkCopyBufferToImageInfo2_win32_to_host(struct convers
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkImageCopy2_win32_to_host(const VkImageCopy232 *in, VkImageCopy2 *out)
+static void convert_VkImageCopy2_win32_to_host(const VkImageCopy232 *in, VkImageCopy2 *out)
 {
     if (!in) return;

@@ -12670,7 +12664,7 @@ static inline void convert_VkImageCopy2_win32_to_host(const VkImageCopy232 *in,
         FIXME("Unexpected pNext\n");
 }

-static inline const VkImageCopy2 *convert_VkImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkImageCopy232 *in, uint32_t count)
+static const VkImageCopy2 *convert_VkImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkImageCopy232 *in, uint32_t count)
 {
     VkImageCopy2 *out;
     unsigned int i;
@@ -12686,7 +12680,7 @@ static inline const VkImageCopy2 *convert_VkImageCopy2_array_win32_to_host(struc
     return out;
 }

-static inline void convert_VkCopyImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageInfo232 *in, VkCopyImageInfo2 *out)
+static void convert_VkCopyImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageInfo232 *in, VkCopyImageInfo2 *out)
 {
     if (!in) return;

@@ -12702,7 +12696,7 @@ static inline void convert_VkCopyImageInfo2_win32_to_host(struct conversion_cont
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCopyImageToBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageToBufferInfo232 *in, VkCopyImageToBufferInfo2 *out)
+static void convert_VkCopyImageToBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageToBufferInfo232 *in, VkCopyImageToBufferInfo2 *out)
 {
     if (!in) return;

@@ -12717,7 +12711,7 @@ static inline void convert_VkCopyImageToBufferInfo2_win32_to_host(struct convers
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(const VkCopyMemoryToAccelerationStructureInfoKHR32 *in, VkCopyMemoryToAccelerationStructureInfoKHR *out)
+static void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(const VkCopyMemoryToAccelerationStructureInfoKHR32 *in, VkCopyMemoryToAccelerationStructureInfoKHR *out)
 {
     if (!in) return;

@@ -12730,7 +12724,7 @@ static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_h
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkCopyMemoryToMicromapInfoEXT32 *in, VkCopyMemoryToMicromapInfoEXT *out)
+static void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkCopyMemoryToMicromapInfoEXT32 *in, VkCopyMemoryToMicromapInfoEXT *out)
 {
     if (!in) return;

@@ -12743,7 +12737,7 @@ static inline void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkC
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicromapInfoEXT32 *in, VkCopyMicromapInfoEXT *out)
+static void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicromapInfoEXT32 *in, VkCopyMicromapInfoEXT *out)
 {
     if (!in) return;

@@ -12756,7 +12750,7 @@ static inline void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicro
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkCopyMicromapToMemoryInfoEXT32 *in, VkCopyMicromapToMemoryInfoEXT *out)
+static void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkCopyMicromapToMemoryInfoEXT32 *in, VkCopyMicromapToMemoryInfoEXT *out)
 {
     if (!in) return;

@@ -12769,7 +12763,7 @@ static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkC
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkTensorCopyARM_win32_to_host(const VkTensorCopyARM32 *in, VkTensorCopyARM *out)
+static void convert_VkTensorCopyARM_win32_to_host(const VkTensorCopyARM32 *in, VkTensorCopyARM *out)
 {
     if (!in) return;

@@ -12783,7 +12777,7 @@ static inline void convert_VkTensorCopyARM_win32_to_host(const VkTensorCopyARM32
         FIXME("Unexpected pNext\n");
 }

-static inline const VkTensorCopyARM *convert_VkTensorCopyARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorCopyARM32 *in, uint32_t count)
+static const VkTensorCopyARM *convert_VkTensorCopyARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorCopyARM32 *in, uint32_t count)
 {
     VkTensorCopyARM *out;
     unsigned int i;
@@ -12799,7 +12793,7 @@ static inline const VkTensorCopyARM *convert_VkTensorCopyARM_array_win32_to_host
     return out;
 }

-static inline void convert_VkCopyTensorInfoARM_win32_to_host(struct conversion_context *ctx, const VkCopyTensorInfoARM32 *in, VkCopyTensorInfoARM *out)
+static void convert_VkCopyTensorInfoARM_win32_to_host(struct conversion_context *ctx, const VkCopyTensorInfoARM32 *in, VkCopyTensorInfoARM *out)
 {
     if (!in) return;

@@ -12813,7 +12807,7 @@ static inline void convert_VkCopyTensorInfoARM_win32_to_host(struct conversion_c
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoNVX32 *in, VkCuLaunchInfoNVX *out)
+static void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoNVX32 *in, VkCuLaunchInfoNVX *out)
 {
     if (!in) return;

@@ -12835,7 +12829,7 @@ static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoN
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebugMarkerMarkerInfoEXT32 *in, VkDebugMarkerMarkerInfoEXT *out)
+static void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebugMarkerMarkerInfoEXT32 *in, VkDebugMarkerMarkerInfoEXT *out)
 {
     if (!in) return;

@@ -12847,7 +12841,7 @@ static inline void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebu
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_StdVideoDecodeVP9PictureInfo_win32_to_host(const StdVideoDecodeVP9PictureInfo32 *in, StdVideoDecodeVP9PictureInfo *out)
+static void convert_StdVideoDecodeVP9PictureInfo_win32_to_host(const StdVideoDecodeVP9PictureInfo32 *in, StdVideoDecodeVP9PictureInfo *out)
 {
     if (!in) return;

@@ -12871,7 +12865,7 @@ static inline void convert_StdVideoDecodeVP9PictureInfo_win32_to_host(const StdV
     out->pSegmentation = UlongToPtr(in->pSegmentation);
 }

-static inline const StdVideoDecodeVP9PictureInfo *convert_StdVideoDecodeVP9PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeVP9PictureInfo32 *in, uint32_t count)
+static const StdVideoDecodeVP9PictureInfo *convert_StdVideoDecodeVP9PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeVP9PictureInfo32 *in, uint32_t count)
 {
     StdVideoDecodeVP9PictureInfo *out;
     unsigned int i;
@@ -12887,7 +12881,7 @@ static inline const StdVideoDecodeVP9PictureInfo *convert_StdVideoDecodeVP9Pictu
     return out;
 }

-static inline void convert_StdVideoAV1TileInfo_win32_to_host(const StdVideoAV1TileInfo32 *in, StdVideoAV1TileInfo *out)
+static void convert_StdVideoAV1TileInfo_win32_to_host(const StdVideoAV1TileInfo32 *in, StdVideoAV1TileInfo *out)
 {
     if (!in) return;

@@ -12903,7 +12897,7 @@ static inline void convert_StdVideoAV1TileInfo_win32_to_host(const StdVideoAV1Ti
     out->pHeightInSbsMinus1 = UlongToPtr(in->pHeightInSbsMinus1);
 }

-static inline const StdVideoAV1TileInfo *convert_StdVideoAV1TileInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoAV1TileInfo32 *in, uint32_t count)
+static const StdVideoAV1TileInfo *convert_StdVideoAV1TileInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoAV1TileInfo32 *in, uint32_t count)
 {
     StdVideoAV1TileInfo *out;
     unsigned int i;
@@ -12919,7 +12913,7 @@ static inline const StdVideoAV1TileInfo *convert_StdVideoAV1TileInfo_array_win32
     return out;
 }

-static inline void convert_StdVideoDecodeAV1PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeAV1PictureInfo32 *in, StdVideoDecodeAV1PictureInfo *out)
+static void convert_StdVideoDecodeAV1PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeAV1PictureInfo32 *in, StdVideoDecodeAV1PictureInfo *out)
 {
     if (!in) return;

@@ -12949,7 +12943,7 @@ static inline void convert_StdVideoDecodeAV1PictureInfo_win32_to_host(struct con
     out->pFilmGrain = UlongToPtr(in->pFilmGrain);
 }

-static inline const StdVideoDecodeAV1PictureInfo *convert_StdVideoDecodeAV1PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeAV1PictureInfo32 *in, uint32_t count)
+static const StdVideoDecodeAV1PictureInfo *convert_StdVideoDecodeAV1PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeAV1PictureInfo32 *in, uint32_t count)
 {
     StdVideoDecodeAV1PictureInfo *out;
     unsigned int i;
@@ -12965,7 +12959,7 @@ static inline const StdVideoDecodeAV1PictureInfo *convert_StdVideoDecodeAV1Pictu
     return out;
 }

-static inline void convert_VkVideoDecodeInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeInfoKHR32 *in, VkVideoDecodeInfoKHR *out)
+static void convert_VkVideoDecodeInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeInfoKHR32 *in, VkVideoDecodeInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -13051,7 +13045,7 @@ static inline void convert_VkVideoDecodeInfoKHR_win32_to_host(struct conversion_
     }
 }

-static inline void convert_VkDecompressMemoryRegionNV_win32_to_host(const VkDecompressMemoryRegionNV32 *in, VkDecompressMemoryRegionNV *out)
+static void convert_VkDecompressMemoryRegionNV_win32_to_host(const VkDecompressMemoryRegionNV32 *in, VkDecompressMemoryRegionNV *out)
 {
     if (!in) return;

@@ -13062,7 +13056,7 @@ static inline void convert_VkDecompressMemoryRegionNV_win32_to_host(const VkDeco
     out->decompressionMethod = in->decompressionMethod;
 }

-static inline const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegionNV_array_win32_to_host(struct conversion_context *ctx, const VkDecompressMemoryRegionNV32 *in, uint32_t count)
+static const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegionNV_array_win32_to_host(struct conversion_context *ctx, const VkDecompressMemoryRegionNV32 *in, uint32_t count)
 {
     VkDecompressMemoryRegionNV *out;
     unsigned int i;
@@ -13078,7 +13072,7 @@ static inline const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegion
     return out;
 }

-static inline void convert_VkDataGraphPipelineDispatchInfoARM_win32_to_host(const VkDataGraphPipelineDispatchInfoARM32 *in, VkDataGraphPipelineDispatchInfoARM *out)
+static void convert_VkDataGraphPipelineDispatchInfoARM_win32_to_host(const VkDataGraphPipelineDispatchInfoARM32 *in, VkDataGraphPipelineDispatchInfoARM *out)
 {
     if (!in) return;

@@ -13089,7 +13083,7 @@ static inline void convert_VkDataGraphPipelineDispatchInfoARM_win32_to_host(cons
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDispatchTileInfoQCOM_win32_to_host(const VkDispatchTileInfoQCOM32 *in, VkDispatchTileInfoQCOM *out)
+static void convert_VkDispatchTileInfoQCOM_win32_to_host(const VkDispatchTileInfoQCOM32 *in, VkDispatchTileInfoQCOM *out)
 {
     if (!in) return;

@@ -13099,7 +13093,7 @@ static inline void convert_VkDispatchTileInfoQCOM_win32_to_host(const VkDispatch
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_StdVideoEncodeH264SliceHeader_win32_to_host(const StdVideoEncodeH264SliceHeader32 *in, StdVideoEncodeH264SliceHeader *out)
+static void convert_StdVideoEncodeH264SliceHeader_win32_to_host(const StdVideoEncodeH264SliceHeader32 *in, StdVideoEncodeH264SliceHeader *out)
 {
     if (!in) return;

@@ -13115,7 +13109,7 @@ static inline void convert_StdVideoEncodeH264SliceHeader_win32_to_host(const Std
     out->pWeightTable = UlongToPtr(in->pWeightTable);
 }

-static inline const StdVideoEncodeH264SliceHeader *convert_StdVideoEncodeH264SliceHeader_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264SliceHeader32 *in, uint32_t count)
+static const StdVideoEncodeH264SliceHeader *convert_StdVideoEncodeH264SliceHeader_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264SliceHeader32 *in, uint32_t count)
 {
     StdVideoEncodeH264SliceHeader *out;
     unsigned int i;
@@ -13131,7 +13125,7 @@ static inline const StdVideoEncodeH264SliceHeader *convert_StdVideoEncodeH264Sli
     return out;
 }

-static inline void convert_VkVideoEncodeH264NaluSliceInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264NaluSliceInfoKHR32 *in, VkVideoEncodeH264NaluSliceInfoKHR *out)
+static void convert_VkVideoEncodeH264NaluSliceInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264NaluSliceInfoKHR32 *in, VkVideoEncodeH264NaluSliceInfoKHR *out)
 {
     if (!in) return;

@@ -13143,7 +13137,7 @@ static inline void convert_VkVideoEncodeH264NaluSliceInfoKHR_win32_to_host(struc
         FIXME("Unexpected pNext\n");
 }

-static inline const VkVideoEncodeH264NaluSliceInfoKHR *convert_VkVideoEncodeH264NaluSliceInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264NaluSliceInfoKHR32 *in, uint32_t count)
+static const VkVideoEncodeH264NaluSliceInfoKHR *convert_VkVideoEncodeH264NaluSliceInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264NaluSliceInfoKHR32 *in, uint32_t count)
 {
     VkVideoEncodeH264NaluSliceInfoKHR *out;
     unsigned int i;
@@ -13159,7 +13153,7 @@ static inline const VkVideoEncodeH264NaluSliceInfoKHR *convert_VkVideoEncodeH264
     return out;
 }

-static inline void convert_StdVideoEncodeH264ReferenceListsInfo_win32_to_host(const StdVideoEncodeH264ReferenceListsInfo32 *in, StdVideoEncodeH264ReferenceListsInfo *out)
+static void convert_StdVideoEncodeH264ReferenceListsInfo_win32_to_host(const StdVideoEncodeH264ReferenceListsInfo32 *in, StdVideoEncodeH264ReferenceListsInfo *out)
 {
     if (!in) return;

@@ -13177,7 +13171,7 @@ static inline void convert_StdVideoEncodeH264ReferenceListsInfo_win32_to_host(co
     out->pRefPicMarkingOperations = UlongToPtr(in->pRefPicMarkingOperations);
 }

-static inline const StdVideoEncodeH264ReferenceListsInfo *convert_StdVideoEncodeH264ReferenceListsInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264ReferenceListsInfo32 *in, uint32_t count)
+static const StdVideoEncodeH264ReferenceListsInfo *convert_StdVideoEncodeH264ReferenceListsInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264ReferenceListsInfo32 *in, uint32_t count)
 {
     StdVideoEncodeH264ReferenceListsInfo *out;
     unsigned int i;
@@ -13193,7 +13187,7 @@ static inline const StdVideoEncodeH264ReferenceListsInfo *convert_StdVideoEncode
     return out;
 }

-static inline void convert_StdVideoEncodeH264PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264PictureInfo32 *in, StdVideoEncodeH264PictureInfo *out)
+static void convert_StdVideoEncodeH264PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264PictureInfo32 *in, StdVideoEncodeH264PictureInfo *out)
 {
     if (!in) return;

@@ -13209,7 +13203,7 @@ static inline void convert_StdVideoEncodeH264PictureInfo_win32_to_host(struct co
     out->pRefLists = convert_StdVideoEncodeH264ReferenceListsInfo_array_win32_to_host(ctx, (const StdVideoEncodeH264ReferenceListsInfo32 *)UlongToPtr(in->pRefLists), 1);
 }

-static inline const StdVideoEncodeH264PictureInfo *convert_StdVideoEncodeH264PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264PictureInfo32 *in, uint32_t count)
+static const StdVideoEncodeH264PictureInfo *convert_StdVideoEncodeH264PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264PictureInfo32 *in, uint32_t count)
 {
     StdVideoEncodeH264PictureInfo *out;
     unsigned int i;
@@ -13225,7 +13219,7 @@ static inline const StdVideoEncodeH264PictureInfo *convert_StdVideoEncodeH264Pic
     return out;
 }

-static inline void convert_StdVideoEncodeAV1PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, StdVideoEncodeAV1PictureInfo *out)
+static void convert_StdVideoEncodeAV1PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, StdVideoEncodeAV1PictureInfo *out)
 {
     if (!in) return;

@@ -13258,7 +13252,7 @@ static inline void convert_StdVideoEncodeAV1PictureInfo_win32_to_host(struct con
     out->pBufferRemovalTimes = UlongToPtr(in->pBufferRemovalTimes);
 }

-static inline const StdVideoEncodeAV1PictureInfo *convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, uint32_t count)
+static const StdVideoEncodeAV1PictureInfo *convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, uint32_t count)
 {
     StdVideoEncodeAV1PictureInfo *out;
     unsigned int i;
@@ -13274,7 +13268,7 @@ static inline const StdVideoEncodeAV1PictureInfo *convert_StdVideoEncodeAV1Pictu
     return out;
 }

-static inline void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeInfoKHR32 *in, VkVideoEncodeInfoKHR *out)
+static void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeInfoKHR32 *in, VkVideoEncodeInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -13372,7 +13366,7 @@ static inline void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_
     }
 }

-static inline void convert_VkPerTileEndInfoQCOM_win32_to_host(const VkPerTileEndInfoQCOM32 *in, VkPerTileEndInfoQCOM *out)
+static void convert_VkPerTileEndInfoQCOM_win32_to_host(const VkPerTileEndInfoQCOM32 *in, VkPerTileEndInfoQCOM *out)
 {
     if (!in) return;

@@ -13382,7 +13376,7 @@ static inline void convert_VkPerTileEndInfoQCOM_win32_to_host(const VkPerTileEnd
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkSubpassEndInfo_win32_to_host(struct conversion_context *ctx, const VkSubpassEndInfo32 *in, VkSubpassEndInfo *out)
+static void convert_VkSubpassEndInfo_win32_to_host(struct conversion_context *ctx, const VkSubpassEndInfo32 *in, VkSubpassEndInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -13415,7 +13409,7 @@ static inline void convert_VkSubpassEndInfo_win32_to_host(struct conversion_cont
     }
 }

-static inline void convert_VkRenderingEndInfoEXT_win32_to_host(struct conversion_context *ctx, const VkRenderingEndInfoEXT32 *in, VkRenderingEndInfoEXT *out)
+static void convert_VkRenderingEndInfoEXT_win32_to_host(struct conversion_context *ctx, const VkRenderingEndInfoEXT32 *in, VkRenderingEndInfoEXT *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -13448,7 +13442,7 @@ static inline void convert_VkRenderingEndInfoEXT_win32_to_host(struct conversion
     }
 }

-static inline void convert_VkVideoEndCodingInfoKHR_win32_to_host(const VkVideoEndCodingInfoKHR32 *in, VkVideoEndCodingInfoKHR *out)
+static void convert_VkVideoEndCodingInfoKHR_win32_to_host(const VkVideoEndCodingInfoKHR32 *in, VkVideoEndCodingInfoKHR *out)
 {
     if (!in) return;

@@ -13460,7 +13454,7 @@ static inline void convert_VkVideoEndCodingInfoKHR_win32_to_host(const VkVideoEn
 }

#ifdef _WIN64
-static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win64_to_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count)
+static const VkCommandBuffer *convert_VkCommandBuffer_array_win64_to_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count)
 {
     VkCommandBuffer *out;
     unsigned int i;
@@ -13477,7 +13471,7 @@ static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win64_to_host
 }
 #endif /* _WIN64 */

-static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
+static const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
 {
     VkCommandBuffer *out;
     unsigned int i;
@@ -13493,7 +13487,7 @@ static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host
     return out;
 }

-static inline void convert_VkGeneratedCommandsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoEXT32 *in, VkGeneratedCommandsInfoEXT *out)
+static void convert_VkGeneratedCommandsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoEXT32 *in, VkGeneratedCommandsInfoEXT *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -13547,7 +13541,7 @@ static inline void convert_VkGeneratedCommandsInfoEXT_win32_to_host(struct conve
     }
 }

-static inline void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndirectCommandsStreamNV32 *in, VkIndirectCommandsStreamNV *out)
+static void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndirectCommandsStreamNV32 *in, VkIndirectCommandsStreamNV *out)
 {
     if (!in) return;

@@ -13555,7 +13549,7 @@ static inline void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndi
     out->offset = in->offset;
 }

-static inline const VkIndirectCommandsStreamNV *convert_VkIndirectCommandsStreamNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsStreamNV32 *in, uint32_t count)
+static const VkIndirectCommandsStreamNV *convert_VkIndirectCommandsStreamNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsStreamNV32 *in, uint32_t count)
 {
     VkIndirectCommandsStreamNV *out;
     unsigned int i;
@@ -13571,7 +13565,7 @@ static inline const VkIndirectCommandsStreamNV *convert_VkIndirectCommandsStream
     return out;
 }

-static inline void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoNV32 *in, VkGeneratedCommandsInfoNV *out)
+static void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoNV32 *in, VkGeneratedCommandsInfoNV *out)
 {
     if (!in) return;

@@ -13594,7 +13588,7 @@ static inline void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conver
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkOpticalFlowExecuteInfoNV_win32_to_host(const VkOpticalFlowExecuteInfoNV32 *in, VkOpticalFlowExecuteInfoNV *out)
+static void convert_VkOpticalFlowExecuteInfoNV_win32_to_host(const VkOpticalFlowExecuteInfoNV32 *in, VkOpticalFlowExecuteInfoNV *out)
 {
     if (!in) return;

@@ -13607,7 +13601,7 @@ static inline void convert_VkOpticalFlowExecuteInfoNV_win32_to_host(const VkOpti
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkMemoryBarrier_win32_to_host(const VkMemoryBarrier32 *in, VkMemoryBarrier *out)
+static void convert_VkMemoryBarrier_win32_to_host(const VkMemoryBarrier32 *in, VkMemoryBarrier *out)
 {
     if (!in) return;

@@ -13619,7 +13613,7 @@ static inline void convert_VkMemoryBarrier_win32_to_host(const VkMemoryBarrier32
         FIXME("Unexpected pNext\n");
 }

-static inline const VkMemoryBarrier *convert_VkMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier32 *in, uint32_t count)
+static const VkMemoryBarrier *convert_VkMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier32 *in, uint32_t count)
 {
     VkMemoryBarrier *out;
     unsigned int i;
@@ -13635,7 +13629,7 @@ static inline const VkMemoryBarrier *convert_VkMemoryBarrier_array_win32_to_host
     return out;
 }

-static inline void convert_VkBufferMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, VkBufferMemoryBarrier *out)
+static void convert_VkBufferMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, VkBufferMemoryBarrier *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -13674,7 +13668,7 @@ static inline void convert_VkBufferMemoryBarrier_win32_to_host(struct conversion
     }
 }

-static inline const VkBufferMemoryBarrier *convert_VkBufferMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, uint32_t count)
+static const VkBufferMemoryBarrier *convert_VkBufferMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, uint32_t count)
 {
     VkBufferMemoryBarrier *out;
     unsigned int i;
@@ -13690,7 +13684,7 @@ static inline const VkBufferMemoryBarrier *convert_VkBufferMemoryBarrier_array_w
     return out;
 }

-static inline void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, VkImageMemoryBarrier *out)
+static void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, VkImageMemoryBarrier *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -13744,7 +13738,7 @@ static inline void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_
     }
 }

-static inline const VkImageMemoryBarrier *convert_VkImageMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, uint32_t count)
+static const VkImageMemoryBarrier *convert_VkImageMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, uint32_t count)
 {
     VkImageMemoryBarrier *out;
     unsigned int i;
@@ -13760,40 +13754,7 @@ static inline const VkImageMemoryBarrier *convert_VkImageMemoryBarrier_array_win
     return out;
 }

-static inline void convert_VkTensorMemoryBarrierARM_win32_to_host(const VkTensorMemoryBarrierARM32 *in, VkTensorMemoryBarrierARM *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->srcStageMask = in->srcStageMask;
-    out->srcAccessMask = in->srcAccessMask;
-    out->dstStageMask = in->dstStageMask;
-    out->dstAccessMask = in->dstAccessMask;
-    out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
-    out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
-    out->tensor = in->tensor;
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
-}
-
-static inline const VkTensorMemoryBarrierARM *convert_VkTensorMemoryBarrierARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorMemoryBarrierARM32 *in, uint32_t count)
-{
-    VkTensorMemoryBarrierARM *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkTensorMemoryBarrierARM_win32_to_host(&in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkMemoryBarrier2_win32_to_host(const VkMemoryBarrier232 *in, VkMemoryBarrier2 *out)
+static void convert_VkMemoryBarrier2_win32_to_host(const VkMemoryBarrier232 *in, VkMemoryBarrier2 *out)
 {
     if (!in) return;

@@ -13807,7 +13768,7 @@ static inline void convert_VkMemoryBarrier2_win32_to_host(const VkMemoryBarrier2
         FIXME("Unexpected pNext\n");
 }

-static inline const VkMemoryBarrier2 *convert_VkMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier232 *in, uint32_t count)
+static const VkMemoryBarrier2 *convert_VkMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier232 *in, uint32_t count)
 {
     VkMemoryBarrier2 *out;
     unsigned int i;
@@ -13823,7 +13784,7 @@ static inline const VkMemoryBarrier2 *convert_VkMemoryBarrier2_array_win32_to_ho
     return out;
 }

-static inline void convert_VkBufferMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, VkBufferMemoryBarrier2 *out)
+static void convert_VkBufferMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, VkBufferMemoryBarrier2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -13876,7 +13837,7 @@ static inline void convert_VkBufferMemoryBarrier2_win32_to_host(struct conversio
     }
 }

-static inline const VkBufferMemoryBarrier2 *convert_VkBufferMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, uint32_t count)
+static const VkBufferMemoryBarrier2 *convert_VkBufferMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, uint32_t count)
 {
     VkBufferMemoryBarrier2 *out;
     unsigned int i;
@@ -13892,7 +13853,7 @@ static inline const VkBufferMemoryBarrier2 *convert_VkBufferMemoryBarrier2_array
     return out;
 }

-static inline void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, VkImageMemoryBarrier2 *out)
+static void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, VkImageMemoryBarrier2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -13960,7 +13921,7 @@ static inline void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion
     }
 }

-static inline const VkImageMemoryBarrier2 *convert_VkImageMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, uint32_t count)
+static const VkImageMemoryBarrier2 *convert_VkImageMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, uint32_t count)
 {
     VkImageMemoryBarrier2 *out;
     unsigned int i;
@@ -13976,7 +13937,40 @@ static inline const VkImageMemoryBarrier2 *convert_VkImageMemoryBarrier2_array_w
     return out;
 }

-static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, VkDependencyInfo *out)
+static void convert_VkTensorMemoryBarrierARM_win32_to_host(const VkTensorMemoryBarrierARM32 *in, VkTensorMemoryBarrierARM *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->srcStageMask = in->srcStageMask;
+    out->srcAccessMask = in->srcAccessMask;
+    out->dstStageMask = in->dstStageMask;
+    out->dstAccessMask = in->dstAccessMask;
+    out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
+    out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
+    out->tensor = in->tensor;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static const VkTensorMemoryBarrierARM *convert_VkTensorMemoryBarrierARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorMemoryBarrierARM32 *in, uint32_t count)
+{
+    VkTensorMemoryBarrierARM *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkTensorMemoryBarrierARM_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, VkDependencyInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -14033,7 +14027,7 @@ static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_cont
     }
 }

-static inline void convert_VkPushConstantsInfo_win32_to_host(struct conversion_context *ctx, const VkPushConstantsInfo32 *in, VkPushConstantsInfo *out)
+static void convert_VkPushConstantsInfo_win32_to_host(struct conversion_context *ctx, const VkPushConstantsInfo32 *in, VkPushConstantsInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -14074,7 +14068,7 @@ static inline void convert_VkPushConstantsInfo_win32_to_host(struct conversion_c
     }
 }

-static inline void convert_VkDescriptorImageInfo_win32_to_host(const VkDescriptorImageInfo32 *in, VkDescriptorImageInfo *out)
+static void convert_VkDescriptorImageInfo_win32_to_host(const VkDescriptorImageInfo32 *in, VkDescriptorImageInfo *out)
 {
     if (!in) return;

@@ -14083,7 +14077,7 @@ static inline void convert_VkDescriptorImageInfo_win32_to_host(const VkDescripto
     out->imageLayout = in->imageLayout;
 }

-static inline const VkDescriptorImageInfo *convert_VkDescriptorImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorImageInfo32 *in, uint32_t count)
+static const VkDescriptorImageInfo *convert_VkDescriptorImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorImageInfo32 *in, uint32_t count)
 {
     VkDescriptorImageInfo *out;
     unsigned int i;
@@ -14099,7 +14093,7 @@ static inline const VkDescriptorImageInfo *convert_VkDescriptorImageInfo_array_w
     return out;
 }

-static inline void convert_VkDescriptorBufferInfo_win32_to_host(const VkDescriptorBufferInfo32 *in, VkDescriptorBufferInfo *out)
+static void convert_VkDescriptorBufferInfo_win32_to_host(const VkDescriptorBufferInfo32 *in, VkDescriptorBufferInfo *out)
 {
     if (!in) return;

@@ -14108,7 +14102,7 @@ static inline void convert_VkDescriptorBufferInfo_win32_to_host(const VkDescript
     out->range = in->range;
 }

-static inline const VkDescriptorBufferInfo *convert_VkDescriptorBufferInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferInfo32 *in, uint32_t count)
+static const VkDescriptorBufferInfo *convert_VkDescriptorBufferInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferInfo32 *in, uint32_t count)
 {
     VkDescriptorBufferInfo *out;
     unsigned int i;
@@ -14124,7 +14118,7 @@ static inline const VkDescriptorBufferInfo *convert_VkDescriptorBufferInfo_array
     return out;
 }

-static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, VkWriteDescriptorSet *out)
+static void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, VkWriteDescriptorSet *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -14213,7 +14207,7 @@ static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_
     }
 }

-static inline const VkWriteDescriptorSet *convert_VkWriteDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, uint32_t count)
+static const VkWriteDescriptorSet *convert_VkWriteDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, uint32_t count)
 {
     VkWriteDescriptorSet *out;
     unsigned int i;
@@ -14229,7 +14223,7 @@ static inline const VkWriteDescriptorSet *convert_VkWriteDescriptorSet_array_win
     return out;
 }

-static inline void convert_VkPushDescriptorSetInfo_win32_to_host(struct conversion_context *ctx, const VkPushDescriptorSetInfo32 *in, VkPushDescriptorSetInfo *out)
+static void convert_VkPushDescriptorSetInfo_win32_to_host(struct conversion_context *ctx, const VkPushDescriptorSetInfo32 *in, VkPushDescriptorSetInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -14270,7 +14264,7 @@ static inline void convert_VkPushDescriptorSetInfo_win32_to_host(struct conversi
     }
 }

-static inline void convert_VkPushDescriptorSetWithTemplateInfo_win32_to_host(struct conversion_context *ctx, const VkPushDescriptorSetWithTemplateInfo32 *in, VkPushDescriptorSetWithTemplateInfo *out)
+static void convert_VkPushDescriptorSetWithTemplateInfo_win32_to_host(struct conversion_context *ctx, const VkPushDescriptorSetWithTemplateInfo32 *in, VkPushDescriptorSetWithTemplateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -14310,7 +14304,7 @@ static inline void convert_VkPushDescriptorSetWithTemplateInfo_win32_to_host(str
     }
 }

-static inline void convert_VkImageResolve2_win32_to_host(const VkImageResolve232 *in, VkImageResolve2 *out)
+static void convert_VkImageResolve2_win32_to_host(const VkImageResolve232 *in, VkImageResolve2 *out)
 {
     if (!in) return;

@@ -14325,7 +14319,7 @@ static inline void convert_VkImageResolve2_win32_to_host(const VkImageResolve232
         FIXME("Unexpected pNext\n");
 }

-static inline const VkImageResolve2 *convert_VkImageResolve2_array_win32_to_host(struct conversion_context *ctx, const VkImageResolve232 *in, uint32_t count)
+static const VkImageResolve2 *convert_VkImageResolve2_array_win32_to_host(struct conversion_context *ctx, const VkImageResolve232 *in, uint32_t count)
 {
     VkImageResolve2 *out;
     unsigned int i;
@@ -14341,7 +14335,7 @@ static inline const VkImageResolve2 *convert_VkImageResolve2_array_win32_to_host
     return out;
 }

-static inline void convert_VkResolveImageInfo2_win32_to_host(struct conversion_context *ctx, const VkResolveImageInfo232 *in, VkResolveImageInfo2 *out)
+static void convert_VkResolveImageInfo2_win32_to_host(struct conversion_context *ctx, const VkResolveImageInfo232 *in, VkResolveImageInfo2 *out)
 {
     if (!in) return;

@@ -14357,7 +14351,7 @@ static inline void convert_VkResolveImageInfo2_win32_to_host(struct conversion_c
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCoarseSampleOrderCustomNV_win32_to_host(const VkCoarseSampleOrderCustomNV32 *in, VkCoarseSampleOrderCustomNV *out)
+static void convert_VkCoarseSampleOrderCustomNV_win32_to_host(const VkCoarseSampleOrderCustomNV32 *in, VkCoarseSampleOrderCustomNV *out)
 {
     if (!in) return;

@@ -14367,7 +14361,7 @@ static inline void convert_VkCoarseSampleOrderCustomNV_win32_to_host(const VkCoa
     out->pSampleLocations = UlongToPtr(in->pSampleLocations);
 }

-static inline const VkCoarseSampleOrderCustomNV *convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(struct conversion_context *ctx, const VkCoarseSampleOrderCustomNV32 *in, uint32_t count)
+static const VkCoarseSampleOrderCustomNV *convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(struct conversion_context *ctx, const VkCoarseSampleOrderCustomNV32 *in, uint32_t count)
 {
     VkCoarseSampleOrderCustomNV *out;
     unsigned int i;
@@ -14383,7 +14377,7 @@ static inline const VkCoarseSampleOrderCustomNV *convert_VkCoarseSampleOrderCust
     return out;
 }

-static inline void convert_VkDepthBiasInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDepthBiasInfoEXT32 *in, VkDepthBiasInfoEXT *out)
+static void convert_VkDepthBiasInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDepthBiasInfoEXT32 *in, VkDepthBiasInfoEXT *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -14419,7 +14413,7 @@ static inline void convert_VkDepthBiasInfoEXT_win32_to_host(struct conversion_co
     }
 }

-static inline void convert_VkSetDescriptorBufferOffsetsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkSetDescriptorBufferOffsetsInfoEXT32 *in, VkSetDescriptorBufferOffsetsInfoEXT *out)
+static void convert_VkSetDescriptorBufferOffsetsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkSetDescriptorBufferOffsetsInfoEXT32 *in, VkSetDescriptorBufferOffsetsInfoEXT *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -14461,7 +14455,7 @@ static inline void convert_VkSetDescriptorBufferOffsetsInfoEXT_win32_to_host(str
     }
 }

-static inline void convert_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPerformanceMarkerInfoINTEL32 *in, VkPerformanceMarkerInfoINTEL *out)
+static void convert_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPerformanceMarkerInfoINTEL32 *in, VkPerformanceMarkerInfoINTEL *out)
 {
     if (!in) return;

@@ -14472,7 +14466,7 @@ static inline void convert_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPe
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPerformanceOverrideInfoINTEL_win32_to_host(const VkPerformanceOverrideInfoINTEL32 *in, VkPerformanceOverrideInfoINTEL *out)
+static void convert_VkPerformanceOverrideInfoINTEL_win32_to_host(const VkPerformanceOverrideInfoINTEL32 *in, VkPerformanceOverrideInfoINTEL *out)
 {
     if (!in) return;

@@ -14485,7 +14479,7 @@ static inline void convert_VkPerformanceOverrideInfoINTEL_win32_to_host(const Vk
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(const VkPerformanceStreamMarkerInfoINTEL32 *in, VkPerformanceStreamMarkerInfoINTEL *out)
+static void convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(const VkPerformanceStreamMarkerInfoINTEL32 *in, VkPerformanceStreamMarkerInfoINTEL *out)
 {
     if (!in) return;

@@ -14496,7 +14490,7 @@ static inline void convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(cons
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkRenderingAttachmentLocationInfo_win32_to_host(const VkRenderingAttachmentLocationInfo32 *in, VkRenderingAttachmentLocationInfo *out)
+static void convert_VkRenderingAttachmentLocationInfo_win32_to_host(const VkRenderingAttachmentLocationInfo32 *in, VkRenderingAttachmentLocationInfo *out)
 {
     if (!in) return;

@@ -14508,7 +14502,7 @@ static inline void convert_VkRenderingAttachmentLocationInfo_win32_to_host(const
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkRenderingInputAttachmentIndexInfo_win32_to_host(const VkRenderingInputAttachmentIndexInfo32 *in, VkRenderingInputAttachmentIndexInfo *out)
+static void convert_VkRenderingInputAttachmentIndexInfo_win32_to_host(const VkRenderingInputAttachmentIndexInfo32 *in, VkRenderingInputAttachmentIndexInfo *out)
 {
     if (!in) return;

@@ -14522,7 +14516,7 @@ static inline void convert_VkRenderingInputAttachmentIndexInfo_win32_to_host(con
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkVertexInputBindingDescription2EXT_win32_to_host(const VkVertexInputBindingDescription2EXT32 *in, VkVertexInputBindingDescription2EXT *out)
+static void convert_VkVertexInputBindingDescription2EXT_win32_to_host(const VkVertexInputBindingDescription2EXT32 *in, VkVertexInputBindingDescription2EXT *out)
 {
     if (!in) return;

@@ -14536,7 +14530,7 @@ static inline void convert_VkVertexInputBindingDescription2EXT_win32_to_host(con
         FIXME("Unexpected pNext\n");
 }

-static inline const VkVertexInputBindingDescription2EXT *convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputBindingDescription2EXT32 *in, uint32_t count)
+static const VkVertexInputBindingDescription2EXT *convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputBindingDescription2EXT32 *in, uint32_t count)
 {
     VkVertexInputBindingDescription2EXT *out;
     unsigned int i;
@@ -14552,7 +14546,7 @@ static inline const VkVertexInputBindingDescription2EXT *convert_VkVertexInputBi
     return out;
 }

-static inline void convert_VkVertexInputAttributeDescription2EXT_win32_to_host(const VkVertexInputAttributeDescription2EXT32 *in, VkVertexInputAttributeDescription2EXT *out)
+static void convert_VkVertexInputAttributeDescription2EXT_win32_to_host(const VkVertexInputAttributeDescription2EXT32 *in, VkVertexInputAttributeDescription2EXT *out)
 {
     if (!in) return;

@@ -14566,7 +14560,7 @@ static inline void convert_VkVertexInputAttributeDescription2EXT_win32_to_host(c
         FIXME("Unexpected pNext\n");
 }

-static inline const VkVertexInputAttributeDescription2EXT *convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputAttributeDescription2EXT32 *in, uint32_t count)
+static const VkVertexInputAttributeDescription2EXT *convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputAttributeDescription2EXT32 *in, uint32_t count)
 {
     VkVertexInputAttributeDescription2EXT *out;
     unsigned int i;
@@ -14582,7 +14576,7 @@ static inline const VkVertexInputAttributeDescription2EXT *convert_VkVertexInput
     return out;
 }

-static inline void convert_VkShadingRatePaletteNV_win32_to_host(const VkShadingRatePaletteNV32 *in, VkShadingRatePaletteNV *out)
+static void convert_VkShadingRatePaletteNV_win32_to_host(const VkShadingRatePaletteNV32 *in, VkShadingRatePaletteNV *out)
 {
     if (!in) return;

@@ -14590,7 +14584,7 @@ static inline void convert_VkShadingRatePaletteNV_win32_to_host(const VkShadingR
     out->pShadingRatePaletteEntries = UlongToPtr(in->pShadingRatePaletteEntries);
 }

-static inline const VkShadingRatePaletteNV *convert_VkShadingRatePaletteNV_array_win32_to_host(struct conversion_context *ctx, const VkShadingRatePaletteNV32 *in, uint32_t count)
+static const VkShadingRatePaletteNV *convert_VkShadingRatePaletteNV_array_win32_to_host(struct conversion_context *ctx, const VkShadingRatePaletteNV32 *in, uint32_t count)
 {
     VkShadingRatePaletteNV *out;
     unsigned int i;
@@ -14606,7 +14600,7 @@ static inline const VkShadingRatePaletteNV *convert_VkShadingRatePaletteNV_array
     return out;
 }

-static inline const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, uint32_t count)
+static const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, uint32_t count)
 {
     VkDependencyInfo *out;
     unsigned int i;
@@ -14622,7 +14616,7 @@ static inline const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_ho
     return out;
 }

-static inline void convert_VkCopyImageToImageInfo_win32_to_host(struct conversion_context *ctx, const VkCopyImageToImageInfo32 *in, VkCopyImageToImageInfo *out)
+static void convert_VkCopyImageToImageInfo_win32_to_host(struct conversion_context *ctx, const VkCopyImageToImageInfo32 *in, VkCopyImageToImageInfo *out)
 {
     if (!in) return;

@@ -14639,7 +14633,7 @@ static inline void convert_VkCopyImageToImageInfo_win32_to_host(struct conversio
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkImageToMemoryCopy_win32_to_host(const VkImageToMemoryCopy32 *in, VkImageToMemoryCopy *out)
+static void convert_VkImageToMemoryCopy_win32_to_host(const VkImageToMemoryCopy32 *in, VkImageToMemoryCopy *out)
 {
     if (!in) return;

@@ -14655,7 +14649,7 @@ static inline void convert_VkImageToMemoryCopy_win32_to_host(const VkImageToMemo
         FIXME("Unexpected pNext\n");
 }

-static inline const VkImageToMemoryCopy *convert_VkImageToMemoryCopy_array_win32_to_host(struct conversion_context *ctx, const VkImageToMemoryCopy32 *in, uint32_t count)
+static const VkImageToMemoryCopy *convert_VkImageToMemoryCopy_array_win32_to_host(struct conversion_context *ctx, const VkImageToMemoryCopy32 *in, uint32_t count)
 {
     VkImageToMemoryCopy *out;
     unsigned int i;
@@ -14671,7 +14665,7 @@ static inline const VkImageToMemoryCopy *convert_VkImageToMemoryCopy_array_win32
     return out;
 }

-static inline void convert_VkCopyImageToMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkCopyImageToMemoryInfo32 *in, VkCopyImageToMemoryInfo *out)
+static void convert_VkCopyImageToMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkCopyImageToMemoryInfo32 *in, VkCopyImageToMemoryInfo *out)
 {
     if (!in) return;

@@ -14686,7 +14680,7 @@ static inline void convert_VkCopyImageToMemoryInfo_win32_to_host(struct conversi
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkMemoryToImageCopy_win32_to_host(const VkMemoryToImageCopy32 *in, VkMemoryToImageCopy *out)
+static void convert_VkMemoryToImageCopy_win32_to_host(const VkMemoryToImageCopy32 *in, VkMemoryToImageCopy *out)
 {
     if (!in) return;

@@ -14702,7 +14696,7 @@ static inline void convert_VkMemoryToImageCopy_win32_to_host(const VkMemoryToIma
         FIXME("Unexpected pNext\n");
 }

-static inline const VkMemoryToImageCopy *convert_VkMemoryToImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkMemoryToImageCopy32 *in, uint32_t count)
+static const VkMemoryToImageCopy *convert_VkMemoryToImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkMemoryToImageCopy32 *in, uint32_t count)
 {
     VkMemoryToImageCopy *out;
     unsigned int i;
@@ -14718,7 +14712,7 @@ static inline const VkMemoryToImageCopy *convert_VkMemoryToImageCopy_array_win32
     return out;
 }

-static inline void convert_VkCopyMemoryToImageInfo_win32_to_host(struct conversion_context *ctx, const VkCopyMemoryToImageInfo32 *in, VkCopyMemoryToImageInfo *out)
+static void convert_VkCopyMemoryToImageInfo_win32_to_host(struct conversion_context *ctx, const VkCopyMemoryToImageInfo32 *in, VkCopyMemoryToImageInfo *out)
 {
     if (!in) return;

@@ -14733,7 +14727,7 @@ static inline void convert_VkCopyMemoryToImageInfo_win32_to_host(struct conversi
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoKHR32 *in, VkAccelerationStructureCreateInfoKHR *out)
+static void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoKHR32 *in, VkAccelerationStructureCreateInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -14783,7 +14777,7 @@ static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(st
     }
 }

-static inline void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoNV32 *in, VkAccelerationStructureCreateInfoNV *out)
+static void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoNV32 *in, VkAccelerationStructureCreateInfoNV *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -14817,7 +14811,7 @@ static inline void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(str
     }
 }

-static inline void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoProfileInfoKHR32 *in, VkVideoProfileInfoKHR *out)
+static void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoProfileInfoKHR32 *in, VkVideoProfileInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -14923,7 +14917,7 @@ static inline void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion
     }
 }

-static inline const VkVideoProfileInfoKHR *convert_VkVideoProfileInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoProfileInfoKHR32 *in, uint32_t count)
+static const VkVideoProfileInfoKHR *convert_VkVideoProfileInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoProfileInfoKHR32 *in, uint32_t count)
 {
     VkVideoProfileInfoKHR *out;
     unsigned int i;
@@ -14939,7 +14933,7 @@ static inline const VkVideoProfileInfoKHR *convert_VkVideoProfileInfoKHR_array_w
     return out;
 }

-static inline void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, VkBufferCreateInfo *out)
+static void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, VkBufferCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -15044,7 +15038,7 @@ static inline void convert_VkBufferCreateInfo_win32_to_host(struct conversion_co
     }
 }

-static inline void convert_VkBufferViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferViewCreateInfo32 *in, VkBufferViewCreateInfo *out)
+static void convert_VkBufferViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferViewCreateInfo32 *in, VkBufferViewCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -15081,7 +15075,7 @@ static inline void convert_VkBufferViewCreateInfo_win32_to_host(struct conversio
     }
 }

-static inline void convert_VkCommandPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkCommandPoolCreateInfo32 *in, VkCommandPoolCreateInfo *out)
+static void convert_VkCommandPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkCommandPoolCreateInfo32 *in, VkCommandPoolCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -15116,104 +15110,23 @@ static inline void convert_VkCommandPoolCreateInfo_win32_to_host(struct conversi
     }
 }

-static inline void convert_VkPipelineCreationFeedback_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out)
+#ifdef _WIN64
+static void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo *out)
 {
+    const VkBaseInStructure *in_header;
+    VkBaseOutStructure *out_header = (void *)out;
+
     if (!in) return;

+    out->sType = in->sType;
+    out->pNext = NULL;
     out->flags = in->flags;
-    out->duration = in->duration;
-}
-
-static inline VkPipelineCreationFeedback *convert_VkPipelineCreationFeedback_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreationFeedback32 *in, uint32_t count)
-{
-    VkPipelineCreationFeedback *out;
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-
-    return out;
-}
-
-static inline void convert_VkPipelineCreationFeedback_array_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out, uint32_t count)
-{
-    unsigned int i;
-
-    if (!in) return;
+    out->stage = in->stage;
+    out->module = in->module;
+    out->pName = in->pName;
+    out->pSpecializationInfo = in->pSpecializationInfo;

-    for (i = 0; i < count; i++)
-    {
-        convert_VkPipelineCreationFeedback_host_to_win32(&in[i], &out[i]);
-    }
-}
-
-static inline void convert_VkSpecializationMapEntry_win32_to_host(const VkSpecializationMapEntry32 *in, VkSpecializationMapEntry *out)
-{
-    if (!in) return;
-
-    out->constantID = in->constantID;
-    out->offset = in->offset;
-    out->size = in->size;
-}
-
-static inline const VkSpecializationMapEntry *convert_VkSpecializationMapEntry_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationMapEntry32 *in, uint32_t count)
-{
-    VkSpecializationMapEntry *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkSpecializationMapEntry_win32_to_host(&in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkSpecializationInfo_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, VkSpecializationInfo *out)
-{
-    if (!in) return;
-
-    out->mapEntryCount = in->mapEntryCount;
-    out->pMapEntries = convert_VkSpecializationMapEntry_array_win32_to_host(ctx, (const VkSpecializationMapEntry32 *)UlongToPtr(in->pMapEntries), in->mapEntryCount);
-    out->dataSize = in->dataSize;
-    out->pData = UlongToPtr(in->pData);
-}
-
-static inline const VkSpecializationInfo *convert_VkSpecializationInfo_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, uint32_t count)
-{
-    VkSpecializationInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkSpecializationInfo_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
-#ifdef _WIN64
-static inline void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo *out)
-{
-    const VkBaseInStructure *in_header;
-    VkBaseOutStructure *out_header = (void *)out;
-
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->flags = in->flags;
-    out->stage = in->stage;
-    out->module = in->module;
-    out->pName = in->pName;
-    out->pSpecializationInfo = in->pSpecializationInfo;
-
-    for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
+    for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
     {
         switch (in_header->sType)
         {
@@ -15299,7 +15212,91 @@ static inline void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct
 }
 #endif /* _WIN64 */

-static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, VkPipelineShaderStageCreateInfo *out)
+#ifdef _WIN64
+static void convert_VkComputePipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, VkComputePipelineCreateInfo *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->flags = in->flags;
+    convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in->stage, &out->stage);
+    out->layout = in->layout;
+    out->basePipelineHandle = in->basePipelineHandle;
+    out->basePipelineIndex = in->basePipelineIndex;
+}
+#endif /* _WIN64 */
+
+#ifdef _WIN64
+static const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, uint32_t count)
+{
+    VkComputePipelineCreateInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkComputePipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+#endif /* _WIN64 */
+
+static void convert_VkSpecializationMapEntry_win32_to_host(const VkSpecializationMapEntry32 *in, VkSpecializationMapEntry *out)
+{
+    if (!in) return;
+
+    out->constantID = in->constantID;
+    out->offset = in->offset;
+    out->size = in->size;
+}
+
+static const VkSpecializationMapEntry *convert_VkSpecializationMapEntry_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationMapEntry32 *in, uint32_t count)
+{
+    VkSpecializationMapEntry *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkSpecializationMapEntry_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkSpecializationInfo_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, VkSpecializationInfo *out)
+{
+    if (!in) return;
+
+    out->mapEntryCount = in->mapEntryCount;
+    out->pMapEntries = convert_VkSpecializationMapEntry_array_win32_to_host(ctx, (const VkSpecializationMapEntry32 *)UlongToPtr(in->pMapEntries), in->mapEntryCount);
+    out->dataSize = in->dataSize;
+    out->pData = UlongToPtr(in->pData);
+}
+
+static const VkSpecializationInfo *convert_VkSpecializationInfo_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, uint32_t count)
+{
+    VkSpecializationInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkSpecializationInfo_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, VkPipelineShaderStageCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -15399,22 +15396,17 @@ static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct
     }
 }

-#ifdef _WIN64
-static inline void convert_VkComputePipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, VkComputePipelineCreateInfo *out)
+static VkPipelineCreationFeedback *convert_VkPipelineCreationFeedback_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreationFeedback32 *in, uint32_t count)
 {
-    if (!in) return;
+    VkPipelineCreationFeedback *out;
+    if (!in || !count) return NULL;

-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->flags = in->flags;
-    convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in->stage, &out->stage);
-    out->layout = in->layout;
-    out->basePipelineHandle = in->basePipelineHandle;
-    out->basePipelineIndex = in->basePipelineIndex;
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+
+    return out;
 }
-#endif /* _WIN64 */

-static inline void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, VkComputePipelineCreateInfo *out)
+static void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, VkComputePipelineCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -15526,7 +15518,43 @@ static inline void convert_VkComputePipelineCreateInfo_win32_to_host(struct conv
     }
 }

-static inline void convert_VkComputePipelineCreateInfo_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out)
+static const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, uint32_t count)
+{
+    VkComputePipelineCreateInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkComputePipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkPipelineCreationFeedback_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out)
+{
+    if (!in) return;
+
+    out->flags = in->flags;
+    out->duration = in->duration;
+}
+
+static void convert_VkPipelineCreationFeedback_array_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out, uint32_t count)
+{
+    unsigned int i;
+
+    if (!in) return;
+
+    for (i = 0; i < count; i++)
+    {
+        convert_VkPipelineCreationFeedback_host_to_win32(&in[i], &out[i]);
+    }
+}
+
+static void convert_VkComputePipelineCreateInfo_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -15554,41 +15582,7 @@ static inline void convert_VkComputePipelineCreateInfo_host_to_win32(const VkCom
     }
 }

-#ifdef _WIN64
-static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, uint32_t count)
-{
-    VkComputePipelineCreateInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkComputePipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-#endif /* _WIN64 */
-
-static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, uint32_t count)
-{
-    VkComputePipelineCreateInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkComputePipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkComputePipelineCreateInfo_array_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out, uint32_t count)
+static void convert_VkComputePipelineCreateInfo_array_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out, uint32_t count)
 {
     unsigned int i;

@@ -15600,7 +15594,7 @@ static inline void convert_VkComputePipelineCreateInfo_array_host_to_win32(const
     }
 }

-static inline void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFunctionCreateInfoNVX32 *in, VkCuFunctionCreateInfoNVX *out)
+static void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFunctionCreateInfoNVX32 *in, VkCuFunctionCreateInfoNVX *out)
 {
     if (!in) return;

@@ -15612,7 +15606,7 @@ static inline void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFun
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(struct conversion_context *ctx, const VkCuModuleCreateInfoNVX32 *in, VkCuModuleCreateInfoNVX *out)
+static void convert_VkCuModuleCreateInfoNVX_win32_to_host(struct conversion_context *ctx, const VkCuModuleCreateInfoNVX32 *in, VkCuModuleCreateInfoNVX *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -15646,7 +15640,7 @@ static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(struct conversi
     }
 }

-static inline void convert_VkDataGraphPipelineSessionCreateInfoARM_win32_to_host(const VkDataGraphPipelineSessionCreateInfoARM32 *in, VkDataGraphPipelineSessionCreateInfoARM *out)
+static void convert_VkDataGraphPipelineSessionCreateInfoARM_win32_to_host(const VkDataGraphPipelineSessionCreateInfoARM32 *in, VkDataGraphPipelineSessionCreateInfoARM *out)
 {
     if (!in) return;

@@ -15658,7 +15652,7 @@ static inline void convert_VkDataGraphPipelineSessionCreateInfoARM_win32_to_host
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineConstantARM32 *in, VkDataGraphPipelineConstantARM *out)
+static void convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineResourceInfoARM32 *in, VkDataGraphPipelineResourceInfoARM *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -15667,8 +15661,9 @@ static inline void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct c

out->sType = in->sType;
     out->pNext = NULL;
-    out->id = in->id;
-    out->pConstantData = UlongToPtr(in->pConstantData);
+    out->descriptorSet = in->descriptorSet;
+    out->binding = in->binding;
+    out->arrayElement = in->arrayElement;

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -15690,19 +15685,6 @@ static inline void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM:
-        {
-            VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *in_ext = (const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM;
-            out_ext->pNext = NULL;
-            out_ext->dimension = in_ext->dimension;
-            out_ext->zeroCount = in_ext->zeroCount;
-            out_ext->groupSize = in_ext->groupSize;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -15710,9 +15692,9 @@ static inline void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct c
     }
 }

-static inline const VkDataGraphPipelineConstantARM *convert_VkDataGraphPipelineConstantARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineConstantARM32 *in, uint32_t count)
+static const VkDataGraphPipelineResourceInfoARM *convert_VkDataGraphPipelineResourceInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineResourceInfoARM32 *in, uint32_t count)
 {
-    VkDataGraphPipelineConstantARM *out;
+    VkDataGraphPipelineResourceInfoARM *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -15720,13 +15702,13 @@ static inline const VkDataGraphPipelineConstantARM *convert_VkDataGraphPipelineC
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkDataGraphPipelineConstantARM_win32_to_host(ctx, &in[i], &out[i]);
+        convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }

-static inline void convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineResourceInfoARM32 *in, VkDataGraphPipelineResourceInfoARM *out)
+static void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineConstantARM32 *in, VkDataGraphPipelineConstantARM *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -15735,9 +15717,8 @@ static inline void convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(stru

out->sType = in->sType;
     out->pNext = NULL;
-    out->descriptorSet = in->descriptorSet;
-    out->binding = in->binding;
-    out->arrayElement = in->arrayElement;
+    out->id = in->id;
+    out->pConstantData = UlongToPtr(in->pConstantData);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -15759,6 +15740,19 @@ static inline void convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(stru
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM:
+        {
+            VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *in_ext = (const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM;
+            out_ext->pNext = NULL;
+            out_ext->dimension = in_ext->dimension;
+            out_ext->zeroCount = in_ext->zeroCount;
+            out_ext->groupSize = in_ext->groupSize;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -15766,9 +15760,9 @@ static inline void convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(stru
     }
 }

-static inline const VkDataGraphPipelineResourceInfoARM *convert_VkDataGraphPipelineResourceInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineResourceInfoARM32 *in, uint32_t count)
+static const VkDataGraphPipelineConstantARM *convert_VkDataGraphPipelineConstantARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineConstantARM32 *in, uint32_t count)
 {
-    VkDataGraphPipelineResourceInfoARM *out;
+    VkDataGraphPipelineConstantARM *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -15776,13 +15770,13 @@ static inline const VkDataGraphPipelineResourceInfoARM *convert_VkDataGraphPipel
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(ctx, &in[i], &out[i]);
+        convert_VkDataGraphPipelineConstantARM_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }

-static inline void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineCreateInfoARM32 *in, VkDataGraphPipelineCreateInfoARM *out)
+static void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineCreateInfoARM32 *in, VkDataGraphPipelineCreateInfoARM *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -15870,7 +15864,23 @@ static inline void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct
     }
 }

-static inline void convert_VkDataGraphPipelineCreateInfoARM_host_to_win32(const VkDataGraphPipelineCreateInfoARM *in, const VkDataGraphPipelineCreateInfoARM32 *out)
+static const VkDataGraphPipelineCreateInfoARM *convert_VkDataGraphPipelineCreateInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineCreateInfoARM32 *in, uint32_t count)
+{
+    VkDataGraphPipelineCreateInfoARM *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkDataGraphPipelineCreateInfoARM_host_to_win32(const VkDataGraphPipelineCreateInfoARM *in, const VkDataGraphPipelineCreateInfoARM32 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -15907,23 +15917,7 @@ static inline void convert_VkDataGraphPipelineCreateInfoARM_host_to_win32(const
     }
 }

-static inline const VkDataGraphPipelineCreateInfoARM *convert_VkDataGraphPipelineCreateInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineCreateInfoARM32 *in, uint32_t count)
-{
-    VkDataGraphPipelineCreateInfoARM *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkDataGraphPipelineCreateInfoARM_array_host_to_win32(const VkDataGraphPipelineCreateInfoARM *in, const VkDataGraphPipelineCreateInfoARM32 *out, uint32_t count)
+static void convert_VkDataGraphPipelineCreateInfoARM_array_host_to_win32(const VkDataGraphPipelineCreateInfoARM *in, const VkDataGraphPipelineCreateInfoARM32 *out, uint32_t count)
 {
     unsigned int i;

@@ -15935,7 +15929,7 @@ static inline void convert_VkDataGraphPipelineCreateInfoARM_array_host_to_win32(
     }
 }

-static inline void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(const VkDebugReportCallbackCreateInfoEXT32 *in, VkDebugReportCallbackCreateInfoEXT *out)
+static void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(const VkDebugReportCallbackCreateInfoEXT32 *in, VkDebugReportCallbackCreateInfoEXT *out)
 {
     if (!in) return;

@@ -15948,7 +15942,7 @@ static inline void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(cons
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(const VkDebugUtilsMessengerCreateInfoEXT32 *in, VkDebugUtilsMessengerCreateInfoEXT *out)
+static void convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(const VkDebugUtilsMessengerCreateInfoEXT32 *in, VkDebugUtilsMessengerCreateInfoEXT *out)
 {
     if (!in) return;

@@ -15963,7 +15957,7 @@ static inline void convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(cons
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkMutableDescriptorTypeListEXT_win32_to_host(const VkMutableDescriptorTypeListEXT32 *in, VkMutableDescriptorTypeListEXT *out)
+static void convert_VkMutableDescriptorTypeListEXT_win32_to_host(const VkMutableDescriptorTypeListEXT32 *in, VkMutableDescriptorTypeListEXT *out)
 {
     if (!in) return;

@@ -15971,7 +15965,7 @@ static inline void convert_VkMutableDescriptorTypeListEXT_win32_to_host(const Vk
     out->pDescriptorTypes = UlongToPtr(in->pDescriptorTypes);
 }

-static inline const VkMutableDescriptorTypeListEXT *convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(struct conversion_context *ctx, const VkMutableDescriptorTypeListEXT32 *in, uint32_t count)
+static const VkMutableDescriptorTypeListEXT *convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(struct conversion_context *ctx, const VkMutableDescriptorTypeListEXT32 *in, uint32_t count)
 {
     VkMutableDescriptorTypeListEXT *out;
     unsigned int i;
@@ -15987,7 +15981,7 @@ static inline const VkMutableDescriptorTypeListEXT *convert_VkMutableDescriptorT
     return out;
 }

-static inline void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorPoolCreateInfo32 *in, VkDescriptorPoolCreateInfo *out)
+static void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorPoolCreateInfo32 *in, VkDescriptorPoolCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -16047,7 +16041,7 @@ static inline void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conve
     }
 }

-static inline void convert_VkDescriptorSetLayoutBinding_win32_to_host(const VkDescriptorSetLayoutBinding32 *in, VkDescriptorSetLayoutBinding *out)
+static void convert_VkDescriptorSetLayoutBinding_win32_to_host(const VkDescriptorSetLayoutBinding32 *in, VkDescriptorSetLayoutBinding *out)
 {
     if (!in) return;

@@ -16058,7 +16052,7 @@ static inline void convert_VkDescriptorSetLayoutBinding_win32_to_host(const VkDe
     out->pImmutableSamplers = UlongToPtr(in->pImmutableSamplers);
 }

-static inline const VkDescriptorSetLayoutBinding *convert_VkDescriptorSetLayoutBinding_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutBinding32 *in, uint32_t count)
+static const VkDescriptorSetLayoutBinding *convert_VkDescriptorSetLayoutBinding_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutBinding32 *in, uint32_t count)
 {
     VkDescriptorSetLayoutBinding *out;
     unsigned int i;
@@ -16074,7 +16068,7 @@ static inline const VkDescriptorSetLayoutBinding *convert_VkDescriptorSetLayoutB
     return out;
 }

-static inline void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutCreateInfo32 *in, VkDescriptorSetLayoutCreateInfo *out)
+static void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutCreateInfo32 *in, VkDescriptorSetLayoutCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -16122,7 +16116,7 @@ static inline void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct
     }
 }

-static inline void convert_VkDescriptorUpdateTemplateEntry_win32_to_host(const VkDescriptorUpdateTemplateEntry32 *in, VkDescriptorUpdateTemplateEntry *out)
+static void convert_VkDescriptorUpdateTemplateEntry_win32_to_host(const VkDescriptorUpdateTemplateEntry32 *in, VkDescriptorUpdateTemplateEntry *out)
 {
     if (!in) return;

@@ -16134,7 +16128,7 @@ static inline void convert_VkDescriptorUpdateTemplateEntry_win32_to_host(const V
     out->stride = in->stride;
 }

-static inline const VkDescriptorUpdateTemplateEntry *convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateEntry32 *in, uint32_t count)
+static const VkDescriptorUpdateTemplateEntry *convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateEntry32 *in, uint32_t count)
 {
     VkDescriptorUpdateTemplateEntry *out;
     unsigned int i;
@@ -16150,7 +16144,7 @@ static inline const VkDescriptorUpdateTemplateEntry *convert_VkDescriptorUpdateT
     return out;
 }

-static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateCreateInfo32 *in, VkDescriptorUpdateTemplateCreateInfo *out)
+static void convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateCreateInfo32 *in, VkDescriptorUpdateTemplateCreateInfo *out)
 {
     if (!in) return;

@@ -16169,7 +16163,7 @@ static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(st
 }

#ifdef _WIN64
-static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win64_to_host(struct conversion_context *ctx, const VkPhysicalDevice *in, uint32_t count)
+static const VkPhysicalDevice *convert_VkPhysicalDevice_array_win64_to_host(struct conversion_context *ctx, const VkPhysicalDevice *in, uint32_t count)
 {
     VkPhysicalDevice *out;
     unsigned int i;
@@ -16186,103 +16180,8 @@ static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win64_to_ho
 }
 #endif /* _WIN64 */

-static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
-{
-    VkPhysicalDevice *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        out[i] = vulkan_physical_device_from_handle(UlongToPtr(in[i]))->host.physical_device;
-    }
-
-    return out;
-}
-
-static inline void convert_VkDeviceQueueCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, VkDeviceQueueCreateInfo *out)
-{
-    const VkBaseInStructure32 *in_header;
-    VkBaseOutStructure *out_header = (void *)out;
-
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->flags = in->flags;
-    out->queueFamilyIndex = in->queueFamilyIndex;
-    out->queueCount = in->queueCount;
-    out->pQueuePriorities = UlongToPtr(in->pQueuePriorities);
-
-    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
-    {
-        switch (in_header->sType)
-        {
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO:
-        {
-            VkDeviceQueueGlobalPriorityCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDeviceQueueGlobalPriorityCreateInfo32 *in_ext = (const VkDeviceQueueGlobalPriorityCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO;
-            out_ext->pNext = NULL;
-            out_ext->globalPriority = in_ext->globalPriority;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
-        {
-            VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDeviceQueueShaderCoreControlCreateInfoARM32 *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM;
-            out_ext->pNext = NULL;
-            out_ext->shaderCoreCount = in_ext->shaderCoreCount;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        default:
-            FIXME("Unhandled sType %u.\n", in_header->sType);
-            break;
-        }
-    }
-}
-
-static inline const VkDeviceQueueCreateInfo *convert_VkDeviceQueueCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, uint32_t count)
-{
-    VkDeviceQueueCreateInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkDeviceQueueCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline const char * const*convert_char_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
-{
-    char **out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        out[i] = UlongToPtr(in[i]);
-    }
-
-    return (void *)out;
-}
-
 #ifdef _WIN64
-static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo *in, VkDeviceCreateInfo *out)
+static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo *in, VkDeviceCreateInfo *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -19091,7 +18990,102 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co
 }
 #endif /* _WIN64 */

-static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo32 *in, VkDeviceCreateInfo *out)
+static void convert_VkDeviceQueueCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, VkDeviceQueueCreateInfo *out)
+{
+    const VkBaseInStructure32 *in_header;
+    VkBaseOutStructure *out_header = (void *)out;
+
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->flags = in->flags;
+    out->queueFamilyIndex = in->queueFamilyIndex;
+    out->queueCount = in->queueCount;
+    out->pQueuePriorities = UlongToPtr(in->pQueuePriorities);
+
+    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+    {
+        switch (in_header->sType)
+        {
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO:
+        {
+            VkDeviceQueueGlobalPriorityCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDeviceQueueGlobalPriorityCreateInfo32 *in_ext = (const VkDeviceQueueGlobalPriorityCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO;
+            out_ext->pNext = NULL;
+            out_ext->globalPriority = in_ext->globalPriority;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
+        {
+            VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDeviceQueueShaderCoreControlCreateInfoARM32 *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM;
+            out_ext->pNext = NULL;
+            out_ext->shaderCoreCount = in_ext->shaderCoreCount;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        default:
+            FIXME("Unhandled sType %u.\n", in_header->sType);
+            break;
+        }
+    }
+}
+
+static const VkDeviceQueueCreateInfo *convert_VkDeviceQueueCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, uint32_t count)
+{
+    VkDeviceQueueCreateInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkDeviceQueueCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static const char * const*convert_char_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
+{
+    char **out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        out[i] = UlongToPtr(in[i]);
+    }
+
+    return (void *)out;
+}
+
+static const VkPhysicalDevice *convert_VkPhysicalDevice_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
+{
+    VkPhysicalDevice *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        out[i] = vulkan_physical_device_from_handle(UlongToPtr(in[i]))->host.physical_device;
+    }
+
+    return out;
+}
+
+static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo32 *in, VkDeviceCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -21899,7 +21893,7 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co
     }
 }

-static inline void convert_VkEventCreateInfo_win32_to_host(const VkEventCreateInfo32 *in, VkEventCreateInfo *out)
+static void convert_VkEventCreateInfo_win32_to_host(const VkEventCreateInfo32 *in, VkEventCreateInfo *out)
 {
     if (!in) return;

@@ -21910,7 +21904,7 @@ static inline void convert_VkEventCreateInfo_win32_to_host(const VkEventCreateIn
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkFenceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFenceCreateInfo32 *in, VkFenceCreateInfo *out)
+static void convert_VkFenceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFenceCreateInfo32 *in, VkFenceCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -21943,7 +21937,7 @@ static inline void convert_VkFenceCreateInfo_win32_to_host(struct conversion_con
     }
 }

-static inline void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const VkFramebufferAttachmentImageInfo32 *in, VkFramebufferAttachmentImageInfo *out)
+static void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const VkFramebufferAttachmentImageInfo32 *in, VkFramebufferAttachmentImageInfo *out)
 {
     if (!in) return;

@@ -21960,7 +21954,7 @@ static inline void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const
         FIXME("Unexpected pNext\n");
 }

-static inline const VkFramebufferAttachmentImageInfo *convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferAttachmentImageInfo32 *in, uint32_t count)
+static const VkFramebufferAttachmentImageInfo *convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferAttachmentImageInfo32 *in, uint32_t count)
 {
     VkFramebufferAttachmentImageInfo *out;
     unsigned int i;
@@ -21976,7 +21970,7 @@ static inline const VkFramebufferAttachmentImageInfo *convert_VkFramebufferAttac
     return out;
 }

-static inline void convert_VkFramebufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFramebufferCreateInfo32 *in, VkFramebufferCreateInfo *out)
+static void convert_VkFramebufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFramebufferCreateInfo32 *in, VkFramebufferCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -22017,7 +22011,7 @@ static inline void convert_VkFramebufferCreateInfo_win32_to_host(struct conversi
 }

#ifdef _WIN64
-static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, uint32_t count)
+static const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, uint32_t count)
 {
     VkPipelineShaderStageCreateInfo *out;
     unsigned int i;
@@ -22034,9 +22028,24 @@ static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderSta
 }
 #endif /* _WIN64 */

-static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, uint32_t count)
+#ifdef _WIN64
+static void convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, VkGraphicsShaderGroupCreateInfoNV *out)
 {
-    VkPipelineShaderStageCreateInfo *out;
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->stageCount = in->stageCount;
+    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
+    out->pVertexInputState = in->pVertexInputState;
+    out->pTessellationState = in->pTessellationState;
+}
+#endif /* _WIN64 */
+
+#ifdef _WIN64
+static const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, uint32_t count)
+{
+    VkGraphicsShaderGroupCreateInfoNV *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -22044,15 +22053,17 @@ static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderSta
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
+        convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
+#endif /* _WIN64 */

-static inline void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, VkPipelineVertexInputStateCreateInfo *out)
+#ifdef _WIN64
+static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, VkGraphicsPipelineCreateInfo *out)
 {
-    const VkBaseInStructure32 *in_header;
+    const VkBaseInStructure *in_header;
     VkBaseOutStructure *out_header = (void *)out;

if (!in) return;
@@ -22060,426 +22071,236 @@ static inline void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(st
     out->sType = in->sType;
     out->pNext = NULL;
     out->flags = in->flags;
-    out->vertexBindingDescriptionCount = in->vertexBindingDescriptionCount;
-    out->pVertexBindingDescriptions = UlongToPtr(in->pVertexBindingDescriptions);
-    out->vertexAttributeDescriptionCount = in->vertexAttributeDescriptionCount;
-    out->pVertexAttributeDescriptions = UlongToPtr(in->pVertexAttributeDescriptions);
+    out->stageCount = in->stageCount;
+    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
+    out->pVertexInputState = in->pVertexInputState;
+    out->pInputAssemblyState = in->pInputAssemblyState;
+    out->pTessellationState = in->pTessellationState;
+    out->pViewportState = in->pViewportState;
+    out->pRasterizationState = in->pRasterizationState;
+    out->pMultisampleState = in->pMultisampleState;
+    out->pDepthStencilState = in->pDepthStencilState;
+    out->pColorBlendState = in->pColorBlendState;
+    out->pDynamicState = in->pDynamicState;
+    out->layout = in->layout;
+    out->renderPass = in->renderPass;
+    out->subpass = in->subpass;
+    out->basePipelineHandle = in->basePipelineHandle;
+    out->basePipelineIndex = in->basePipelineIndex;

-    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+    for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
         {
-            VkPipelineVertexInputDivisorStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineVertexInputDivisorStateCreateInfo32 *in_ext = (const VkPipelineVertexInputDivisorStateCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO;
+            VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCreateFlags2CreateInfo *in_ext = (const VkPipelineCreateFlags2CreateInfo *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->vertexBindingDivisorCount = in_ext->vertexBindingDivisorCount;
-            out_ext->pVertexBindingDivisors = UlongToPtr(in_ext->pVertexBindingDivisors);
+            out_ext->flags = in_ext->flags;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        default:
-            FIXME("Unhandled sType %u.\n", in_header->sType);
-            break;
-        }
-    }
-}
-
-static inline const VkPipelineVertexInputStateCreateInfo *convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, uint32_t count)
-{
-    VkPipelineVertexInputStateCreateInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkPipelineTessellationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, VkPipelineTessellationStateCreateInfo *out)
-{
-    const VkBaseInStructure32 *in_header;
-    VkBaseOutStructure *out_header = (void *)out;
-
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->flags = in->flags;
-    out->patchControlPoints = in->patchControlPoints;
-
-    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
-    {
-        switch (in_header->sType)
-        {
-        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
         {
-            VkPipelineTessellationDomainOriginStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineTessellationDomainOriginStateCreateInfo32 *in_ext = (const VkPipelineTessellationDomainOriginStateCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
+            VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineBinaryInfoKHR *in_ext = (const VkPipelineBinaryInfoKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->domainOrigin = in_ext->domainOrigin;
+            out_ext->binaryCount = in_ext->binaryCount;
+            out_ext->pPipelineBinaries = in_ext->pPipelineBinaries;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        default:
-            FIXME("Unhandled sType %u.\n", in_header->sType);
-            break;
-        }
-    }
-}
-
-static inline const VkPipelineTessellationStateCreateInfo *convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, uint32_t count)
-{
-    VkPipelineTessellationStateCreateInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkPipelineTessellationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
-#ifdef _WIN64
-static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, VkGraphicsShaderGroupCreateInfoNV *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->stageCount = in->stageCount;
-    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
-    out->pVertexInputState = in->pVertexInputState;
-    out->pTessellationState = in->pTessellationState;
-}
-#endif /* _WIN64 */
-
-static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, VkGraphicsShaderGroupCreateInfoNV *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->stageCount = in->stageCount;
-    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
-    out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1);
-    out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1);
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
-}
-
-#ifdef _WIN64
-static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, uint32_t count)
-{
-    VkGraphicsShaderGroupCreateInfoNV *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-#endif /* _WIN64 */
-
-static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, uint32_t count)
-{
-    VkGraphicsShaderGroupCreateInfoNV *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(const VkPipelineInputAssemblyStateCreateInfo32 *in, VkPipelineInputAssemblyStateCreateInfo *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->flags = in->flags;
-    out->topology = in->topology;
-    out->primitiveRestartEnable = in->primitiveRestartEnable;
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
-}
-
-static inline const VkPipelineInputAssemblyStateCreateInfo *convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineInputAssemblyStateCreateInfo32 *in, uint32_t count)
-{
-    VkPipelineInputAssemblyStateCreateInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(&in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, VkPipelineViewportStateCreateInfo *out)
-{
-    const VkBaseInStructure32 *in_header;
-    VkBaseOutStructure *out_header = (void *)out;
-
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->flags = in->flags;
-    out->viewportCount = in->viewportCount;
-    out->pViewports = UlongToPtr(in->pViewports);
-    out->scissorCount = in->scissorCount;
-    out->pScissors = UlongToPtr(in->pScissors);
-
-    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
-    {
-        switch (in_header->sType)
-        {
-        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
         {
-            VkPipelineViewportWScalingStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineViewportWScalingStateCreateInfoNV32 *in_ext = (const VkPipelineViewportWScalingStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV;
+            VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkGraphicsPipelineShaderGroupsCreateInfoNV *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable;
-            out_ext->viewportCount = in_ext->viewportCount;
-            out_ext->pViewportWScalings = UlongToPtr(in_ext->pViewportWScalings);
+            out_ext->groupCount = in_ext->groupCount;
+            out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(ctx, in_ext->pGroups, in_ext->groupCount);
+            out_ext->pipelineCount = in_ext->pipelineCount;
+            out_ext->pPipelines = in_ext->pPipelines;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
         {
-            VkPipelineViewportSwizzleStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineViewportSwizzleStateCreateInfoNV32 *in_ext = (const VkPipelineViewportSwizzleStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV;
+            VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
-            out_ext->viewportCount = in_ext->viewportCount;
-            out_ext->pViewportSwizzles = UlongToPtr(in_ext->pViewportSwizzles);
+            out_ext->discardRectangleMode = in_ext->discardRectangleMode;
+            out_ext->discardRectangleCount = in_ext->discardRectangleCount;
+            out_ext->pDiscardRectangles = in_ext->pDiscardRectangles;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
         {
-            VkPipelineViewportExclusiveScissorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *in_ext = (const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV;
+            VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->exclusiveScissorCount = in_ext->exclusiveScissorCount;
-            out_ext->pExclusiveScissors = UlongToPtr(in_ext->pExclusiveScissors);
+            out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
         {
-            VkPipelineViewportShadingRateImageStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *in_ext = (const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV;
+            VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->shadingRateImageEnable = in_ext->shadingRateImageEnable;
-            out_ext->viewportCount = in_ext->viewportCount;
-            out_ext->pShadingRatePalettes = convert_VkShadingRatePaletteNV_array_win32_to_host(ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(in_ext->pShadingRatePalettes), in_ext->viewportCount);
+            out_ext->pPipelineCreationFeedback = in_ext->pPipelineCreationFeedback;
+            out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
+            out_ext->pPipelineStageCreationFeedbacks = in_ext->pPipelineStageCreationFeedbacks;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
         {
-            VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *in_ext = (const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV;
+            VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
             out_ext->pNext = NULL;
-            out_ext->sampleOrderType = in_ext->sampleOrderType;
-            out_ext->customSampleOrderCount = in_ext->customSampleOrderCount;
-            out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(in_ext->pCustomSampleOrders), in_ext->customSampleOrderCount);
+            out_ext->compilerControlFlags = in_ext->compilerControlFlags;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
         {
-            VkPipelineViewportDepthClipControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineViewportDepthClipControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClipControlCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT;
+            VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->negativeOneToOne = in_ext->negativeOneToOne;
+            out_ext->libraryCount = in_ext->libraryCount;
+            out_ext->pLibraries = in_ext->pLibraries;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
         {
-            VkPipelineViewportDepthClampControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineViewportDepthClampControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClampControlCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT;
+            VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineFragmentShadingRateStateCreateInfoKHR *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->depthClampMode = in_ext->depthClampMode;
-            out_ext->pDepthClampRange = UlongToPtr(in_ext->pDepthClampRange);
+            out_ext->fragmentSize = in_ext->fragmentSize;
+            memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        default:
-            FIXME("Unhandled sType %u.\n", in_header->sType);
+        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
+        {
+            VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
+            out_ext->pNext = NULL;
+            out_ext->shadingRateType = in_ext->shadingRateType;
+            out_ext->shadingRate = in_ext->shadingRate;
+            memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
             break;
         }
-    }
-}
-
-static inline const VkPipelineViewportStateCreateInfo *convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, uint32_t count)
-{
-    VkPipelineViewportStateCreateInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkPipelineViewportStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, VkPipelineRasterizationStateCreateInfo *out)
-{
-    const VkBaseInStructure32 *in_header;
-    VkBaseOutStructure *out_header = (void *)out;
-
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->flags = in->flags;
-    out->depthClampEnable = in->depthClampEnable;
-    out->rasterizerDiscardEnable = in->rasterizerDiscardEnable;
-    out->polygonMode = in->polygonMode;
-    out->cullMode = in->cullMode;
-    out->frontFace = in->frontFace;
-    out->depthBiasEnable = in->depthBiasEnable;
-    out->depthBiasConstantFactor = in->depthBiasConstantFactor;
-    out->depthBiasClamp = in->depthBiasClamp;
-    out->depthBiasSlopeFactor = in->depthBiasSlopeFactor;
-    out->lineWidth = in->lineWidth;
-
-    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
-    {
-        switch (in_header->sType)
-        {
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
         {
-            VkPipelineRasterizationStateRasterizationOrderAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRasterizationStateRasterizationOrderAMD32 *in_ext = (const VkPipelineRasterizationStateRasterizationOrderAMD32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD;
+            VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRenderingCreateInfo *in_ext = (const VkPipelineRenderingCreateInfo *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->rasterizationOrder = in_ext->rasterizationOrder;
+            out_ext->viewMask = in_ext->viewMask;
+            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
+            out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats;
+            out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
+            out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
         {
-            VkPipelineRasterizationConservativeStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT;
+            VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->conservativeRasterizationMode = in_ext->conservativeRasterizationMode;
-            out_ext->extraPrimitiveOverestimationSize = in_ext->extraPrimitiveOverestimationSize;
+            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
+            out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
+            out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
         {
-            VkPipelineRasterizationStateStreamCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRasterizationStateStreamCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationStateStreamCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT;
+            VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
-            out_ext->rasterizationStream = in_ext->rasterizationStream;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
         {
-            VkPipelineRasterizationDepthClipStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT;
+            VkPipelineRobustnessCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRobustnessCreateInfo *in_ext = (const VkPipelineRobustnessCreateInfo *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->depthClipEnable = in_ext->depthClipEnable;
+            out_ext->storageBuffers = in_ext->storageBuffers;
+            out_ext->uniformBuffers = in_ext->uniformBuffers;
+            out_ext->vertexInputs = in_ext->vertexInputs;
+            out_ext->images = in_ext->images;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO:
         {
-            VkPipelineRasterizationLineStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRasterizationLineStateCreateInfo32 *in_ext = (const VkPipelineRasterizationLineStateCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO;
+            VkRenderingAttachmentLocationInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRenderingAttachmentLocationInfo *in_ext = (const VkRenderingAttachmentLocationInfo *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO;
             out_ext->pNext = NULL;
-            out_ext->lineRasterizationMode = in_ext->lineRasterizationMode;
-            out_ext->stippledLineEnable = in_ext->stippledLineEnable;
-            out_ext->lineStippleFactor = in_ext->lineStippleFactor;
-            out_ext->lineStipplePattern = in_ext->lineStipplePattern;
+            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
+            out_ext->pColorAttachmentLocations = in_ext->pColorAttachmentLocations;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO:
         {
-            VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT;
+            VkRenderingInputAttachmentIndexInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRenderingInputAttachmentIndexInfo *in_ext = (const VkRenderingInputAttachmentIndexInfo *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO;
             out_ext->pNext = NULL;
-            out_ext->provokingVertexMode = in_ext->provokingVertexMode;
+            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
+            out_ext->pColorAttachmentInputIndices = in_ext->pColorAttachmentInputIndices;
+            out_ext->pDepthInputAttachmentIndex = in_ext->pDepthInputAttachmentIndex;
+            out_ext->pStencilInputAttachmentIndex = in_ext->pStencilInputAttachmentIndex;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE:
         {
-            VkDepthBiasRepresentationInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDepthBiasRepresentationInfoEXT32 *in_ext = (const VkDepthBiasRepresentationInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT;
+            VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE;
             out_ext->pNext = NULL;
-            out_ext->depthBiasRepresentation = in_ext->depthBiasRepresentation;
-            out_ext->depthBiasExact = in_ext->depthBiasExact;
+            out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22490,10 +22311,12 @@ static inline void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(
         }
     }
 }
+#endif /* _WIN64 */

-static inline const VkPipelineRasterizationStateCreateInfo *convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, uint32_t count)
+#ifdef _WIN64
+static const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, uint32_t count)
 {
-    VkPipelineRasterizationStateCreateInfo *out;
+    VkGraphicsPipelineCreateInfo *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -22501,81 +22324,56 @@ static inline const VkPipelineRasterizationStateCreateInfo *convert_VkPipelineRa
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
+        convert_VkGraphicsPipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
+#endif /* _WIN64 */

-static inline void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, VkPipelineMultisampleStateCreateInfo *out)
+static const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, uint32_t count)
 {
-    const VkBaseInStructure32 *in_header;
-    VkBaseOutStructure *out_header = (void *)out;
-
-    if (!in) return;
+    VkPipelineShaderStageCreateInfo *out;
+    unsigned int i;

-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->flags = in->flags;
-    out->rasterizationSamples = in->rasterizationSamples;
-    out->sampleShadingEnable = in->sampleShadingEnable;
-    out->minSampleShading = in->minSampleShading;
-    out->pSampleMask = UlongToPtr(in->pSampleMask);
-    out->alphaToCoverageEnable = in->alphaToCoverageEnable;
-    out->alphaToOneEnable = in->alphaToOneEnable;
+    if (!in || !count) return NULL;

-    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
     {
-        switch (in_header->sType)
-        {
-        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
-        {
-            VkPipelineCoverageToColorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCoverageToColorStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageToColorStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV;
-            out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->coverageToColorEnable = in_ext->coverageToColorEnable;
-            out_ext->coverageToColorLocation = in_ext->coverageToColorLocation;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
-        {
-            VkPipelineSampleLocationsStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineSampleLocationsStateCreateInfoEXT32 *in_ext = (const VkPipelineSampleLocationsStateCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->sampleLocationsEnable = in_ext->sampleLocationsEnable;
-            convert_VkSampleLocationsInfoEXT_win32_to_host(&in_ext->sampleLocationsInfo, &out_ext->sampleLocationsInfo);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+        convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, VkPipelineVertexInputStateCreateInfo *out)
+{
+    const VkBaseInStructure32 *in_header;
+    VkBaseOutStructure *out_header = (void *)out;
+
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->flags = in->flags;
+    out->vertexBindingDescriptionCount = in->vertexBindingDescriptionCount;
+    out->pVertexBindingDescriptions = UlongToPtr(in->pVertexBindingDescriptions);
+    out->vertexAttributeDescriptionCount = in->vertexAttributeDescriptionCount;
+    out->pVertexAttributeDescriptions = UlongToPtr(in->pVertexAttributeDescriptions);
+
+    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+    {
+        switch (in_header->sType)
         {
-            VkPipelineCoverageModulationStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCoverageModulationStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageModulationStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV;
-            out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->coverageModulationMode = in_ext->coverageModulationMode;
-            out_ext->coverageModulationTableEnable = in_ext->coverageModulationTableEnable;
-            out_ext->coverageModulationTableCount = in_ext->coverageModulationTableCount;
-            out_ext->pCoverageModulationTable = UlongToPtr(in_ext->pCoverageModulationTable);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO:
         {
-            VkPipelineCoverageReductionStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCoverageReductionStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageReductionStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV;
+            VkPipelineVertexInputDivisorStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineVertexInputDivisorStateCreateInfo32 *in_ext = (const VkPipelineVertexInputDivisorStateCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->coverageReductionMode = in_ext->coverageReductionMode;
+            out_ext->vertexBindingDivisorCount = in_ext->vertexBindingDivisorCount;
+            out_ext->pVertexBindingDivisors = UlongToPtr(in_ext->pVertexBindingDivisors);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22587,9 +22385,9 @@ static inline void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(st
     }
 }

-static inline const VkPipelineMultisampleStateCreateInfo *convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, uint32_t count)
+static const VkPipelineVertexInputStateCreateInfo *convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, uint32_t count)
 {
-    VkPipelineMultisampleStateCreateInfo *out;
+    VkPipelineVertexInputStateCreateInfo *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -22597,35 +22395,28 @@ static inline const VkPipelineMultisampleStateCreateInfo *convert_VkPipelineMult
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
+        convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }

-static inline void convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(const VkPipelineDepthStencilStateCreateInfo32 *in, VkPipelineDepthStencilStateCreateInfo *out)
+static void convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(const VkPipelineInputAssemblyStateCreateInfo32 *in, VkPipelineInputAssemblyStateCreateInfo *out)
 {
     if (!in) return;

out->sType = in->sType;
     out->pNext = NULL;
     out->flags = in->flags;
-    out->depthTestEnable = in->depthTestEnable;
-    out->depthWriteEnable = in->depthWriteEnable;
-    out->depthCompareOp = in->depthCompareOp;
-    out->depthBoundsTestEnable = in->depthBoundsTestEnable;
-    out->stencilTestEnable = in->stencilTestEnable;
-    out->front = in->front;
-    out->back = in->back;
-    out->minDepthBounds = in->minDepthBounds;
-    out->maxDepthBounds = in->maxDepthBounds;
+    out->topology = in->topology;
+    out->primitiveRestartEnable = in->primitiveRestartEnable;
     if (in->pNext)
         FIXME("Unexpected pNext\n");
 }

-static inline const VkPipelineDepthStencilStateCreateInfo *convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDepthStencilStateCreateInfo32 *in, uint32_t count)
+static const VkPipelineInputAssemblyStateCreateInfo *convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineInputAssemblyStateCreateInfo32 *in, uint32_t count)
 {
-    VkPipelineDepthStencilStateCreateInfo *out;
+    VkPipelineInputAssemblyStateCreateInfo *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -22633,13 +22424,13 @@ static inline const VkPipelineDepthStencilStateCreateInfo *convert_VkPipelineDep
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(&in[i], &out[i]);
+        convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(&in[i], &out[i]);
     }

return out;
 }

-static inline void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, VkPipelineColorBlendStateCreateInfo *out)
+static void convert_VkPipelineTessellationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, VkPipelineTessellationStateCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -22649,37 +22440,19 @@ static inline void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(str
     out->sType = in->sType;
     out->pNext = NULL;
     out->flags = in->flags;
-    out->logicOpEnable = in->logicOpEnable;
-    out->logicOp = in->logicOp;
-    out->attachmentCount = in->attachmentCount;
-    out->pAttachments = UlongToPtr(in->pAttachments);
-    memcpy(out->blendConstants, in->blendConstants, 4 * sizeof(float));
+    out->patchControlPoints = in->patchControlPoints;

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
-        {
-            VkPipelineColorBlendAdvancedStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *in_ext = (const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->srcPremultiplied = in_ext->srcPremultiplied;
-            out_ext->dstPremultiplied = in_ext->dstPremultiplied;
-            out_ext->blendOverlap = in_ext->blendOverlap;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
         {
-            VkPipelineColorWriteCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineColorWriteCreateInfoEXT32 *in_ext = (const VkPipelineColorWriteCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT;
+            VkPipelineTessellationDomainOriginStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineTessellationDomainOriginStateCreateInfo32 *in_ext = (const VkPipelineTessellationDomainOriginStateCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->attachmentCount = in_ext->attachmentCount;
-            out_ext->pColorWriteEnables = UlongToPtr(in_ext->pColorWriteEnables);
+            out_ext->domainOrigin = in_ext->domainOrigin;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22691,9 +22464,9 @@ static inline void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(str
     }
 }

-static inline const VkPipelineColorBlendStateCreateInfo *convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, uint32_t count)
+static const VkPipelineTessellationStateCreateInfo *convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, uint32_t count)
 {
-    VkPipelineColorBlendStateCreateInfo *out;
+    VkPipelineTessellationStateCreateInfo *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -22701,28 +22474,128 @@ static inline const VkPipelineColorBlendStateCreateInfo *convert_VkPipelineColor
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
+        convert_VkPipelineTessellationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }

-static inline void convert_VkPipelineDynamicStateCreateInfo_win32_to_host(const VkPipelineDynamicStateCreateInfo32 *in, VkPipelineDynamicStateCreateInfo *out)
+static void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, VkPipelineViewportStateCreateInfo *out)
 {
+    const VkBaseInStructure32 *in_header;
+    VkBaseOutStructure *out_header = (void *)out;
+
     if (!in) return;

out->sType = in->sType;
     out->pNext = NULL;
     out->flags = in->flags;
-    out->dynamicStateCount = in->dynamicStateCount;
-    out->pDynamicStates = UlongToPtr(in->pDynamicStates);
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
+    out->viewportCount = in->viewportCount;
+    out->pViewports = UlongToPtr(in->pViewports);
+    out->scissorCount = in->scissorCount;
+    out->pScissors = UlongToPtr(in->pScissors);
+
+    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+    {
+        switch (in_header->sType)
+        {
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+        {
+            VkPipelineViewportWScalingStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineViewportWScalingStateCreateInfoNV32 *in_ext = (const VkPipelineViewportWScalingStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV;
+            out_ext->pNext = NULL;
+            out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable;
+            out_ext->viewportCount = in_ext->viewportCount;
+            out_ext->pViewportWScalings = UlongToPtr(in_ext->pViewportWScalings);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+        {
+            VkPipelineViewportSwizzleStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineViewportSwizzleStateCreateInfoNV32 *in_ext = (const VkPipelineViewportSwizzleStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV;
+            out_ext->pNext = NULL;
+            out_ext->flags = in_ext->flags;
+            out_ext->viewportCount = in_ext->viewportCount;
+            out_ext->pViewportSwizzles = UlongToPtr(in_ext->pViewportSwizzles);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
+        {
+            VkPipelineViewportExclusiveScissorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *in_ext = (const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV;
+            out_ext->pNext = NULL;
+            out_ext->exclusiveScissorCount = in_ext->exclusiveScissorCount;
+            out_ext->pExclusiveScissors = UlongToPtr(in_ext->pExclusiveScissors);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
+        {
+            VkPipelineViewportShadingRateImageStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *in_ext = (const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV;
+            out_ext->pNext = NULL;
+            out_ext->shadingRateImageEnable = in_ext->shadingRateImageEnable;
+            out_ext->viewportCount = in_ext->viewportCount;
+            out_ext->pShadingRatePalettes = convert_VkShadingRatePaletteNV_array_win32_to_host(ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(in_ext->pShadingRatePalettes), in_ext->viewportCount);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
+        {
+            VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *in_ext = (const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV;
+            out_ext->pNext = NULL;
+            out_ext->sampleOrderType = in_ext->sampleOrderType;
+            out_ext->customSampleOrderCount = in_ext->customSampleOrderCount;
+            out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(in_ext->pCustomSampleOrders), in_ext->customSampleOrderCount);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
+        {
+            VkPipelineViewportDepthClipControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineViewportDepthClipControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClipControlCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->negativeOneToOne = in_ext->negativeOneToOne;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
+        {
+            VkPipelineViewportDepthClampControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineViewportDepthClampControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClampControlCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->depthClampMode = in_ext->depthClampMode;
+            out_ext->pDepthClampRange = UlongToPtr(in_ext->pDepthClampRange);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        default:
+            FIXME("Unhandled sType %u.\n", in_header->sType);
+            break;
+        }
+    }
 }

-static inline const VkPipelineDynamicStateCreateInfo *convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDynamicStateCreateInfo32 *in, uint32_t count)
+static const VkPipelineViewportStateCreateInfo *convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, uint32_t count)
 {
-    VkPipelineDynamicStateCreateInfo *out;
+    VkPipelineViewportStateCreateInfo *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -22730,16 +22603,15 @@ static inline const VkPipelineDynamicStateCreateInfo *convert_VkPipelineDynamicS
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkPipelineDynamicStateCreateInfo_win32_to_host(&in[i], &out[i]);
+        convert_VkPipelineViewportStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }

-#ifdef _WIN64
-static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, VkGraphicsPipelineCreateInfo *out)
+static void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, VkPipelineRasterizationStateCreateInfo *out)
 {
-    const VkBaseInStructure *in_header;
+    const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;

if (!in) return;
@@ -22747,236 +22619,302 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct con
     out->sType = in->sType;
     out->pNext = NULL;
     out->flags = in->flags;
-    out->stageCount = in->stageCount;
-    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
-    out->pVertexInputState = in->pVertexInputState;
-    out->pInputAssemblyState = in->pInputAssemblyState;
-    out->pTessellationState = in->pTessellationState;
-    out->pViewportState = in->pViewportState;
-    out->pRasterizationState = in->pRasterizationState;
-    out->pMultisampleState = in->pMultisampleState;
-    out->pDepthStencilState = in->pDepthStencilState;
-    out->pColorBlendState = in->pColorBlendState;
-    out->pDynamicState = in->pDynamicState;
-    out->layout = in->layout;
-    out->renderPass = in->renderPass;
-    out->subpass = in->subpass;
-    out->basePipelineHandle = in->basePipelineHandle;
-    out->basePipelineIndex = in->basePipelineIndex;
-
-    for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
-    {
-        switch (in_header->sType)
-        {
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
-        {
-            VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCreateFlags2CreateInfo *in_ext = (const VkPipelineCreateFlags2CreateInfo *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
-            out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
+    out->depthClampEnable = in->depthClampEnable;
+    out->rasterizerDiscardEnable = in->rasterizerDiscardEnable;
+    out->polygonMode = in->polygonMode;
+    out->cullMode = in->cullMode;
+    out->frontFace = in->frontFace;
+    out->depthBiasEnable = in->depthBiasEnable;
+    out->depthBiasConstantFactor = in->depthBiasConstantFactor;
+    out->depthBiasClamp = in->depthBiasClamp;
+    out->depthBiasSlopeFactor = in->depthBiasSlopeFactor;
+    out->lineWidth = in->lineWidth;
+
+    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+    {
+        switch (in_header->sType)
         {
-            VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineBinaryInfoKHR *in_ext = (const VkPipelineBinaryInfoKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+        {
+            VkPipelineRasterizationStateRasterizationOrderAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRasterizationStateRasterizationOrderAMD32 *in_ext = (const VkPipelineRasterizationStateRasterizationOrderAMD32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD;
             out_ext->pNext = NULL;
-            out_ext->binaryCount = in_ext->binaryCount;
-            out_ext->pPipelineBinaries = in_ext->pPipelineBinaries;
+            out_ext->rasterizationOrder = in_ext->rasterizationOrder;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
         {
-            VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkGraphicsPipelineShaderGroupsCreateInfoNV *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
+            VkPipelineRasterizationConservativeStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->groupCount = in_ext->groupCount;
-            out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(ctx, in_ext->pGroups, in_ext->groupCount);
-            out_ext->pipelineCount = in_ext->pipelineCount;
-            out_ext->pPipelines = in_ext->pPipelines;
+            out_ext->flags = in_ext->flags;
+            out_ext->conservativeRasterizationMode = in_ext->conservativeRasterizationMode;
+            out_ext->extraPrimitiveOverestimationSize = in_ext->extraPrimitiveOverestimationSize;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
         {
-            VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
+            VkPipelineRasterizationStateStreamCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRasterizationStateStreamCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationStateStreamCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
-            out_ext->discardRectangleMode = in_ext->discardRectangleMode;
-            out_ext->discardRectangleCount = in_ext->discardRectangleCount;
-            out_ext->pDiscardRectangles = in_ext->pDiscardRectangles;
+            out_ext->rasterizationStream = in_ext->rasterizationStream;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
         {
-            VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
+            VkPipelineRasterizationDepthClipStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
+            out_ext->flags = in_ext->flags;
+            out_ext->depthClipEnable = in_ext->depthClipEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO:
         {
-            VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
+            VkPipelineRasterizationLineStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRasterizationLineStateCreateInfo32 *in_ext = (const VkPipelineRasterizationLineStateCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->pPipelineCreationFeedback = in_ext->pPipelineCreationFeedback;
-            out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
-            out_ext->pPipelineStageCreationFeedbacks = in_ext->pPipelineStageCreationFeedbacks;
+            out_ext->lineRasterizationMode = in_ext->lineRasterizationMode;
+            out_ext->stippledLineEnable = in_ext->stippledLineEnable;
+            out_ext->lineStippleFactor = in_ext->lineStippleFactor;
+            out_ext->lineStipplePattern = in_ext->lineStipplePattern;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
         {
-            VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
+            VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->compilerControlFlags = in_ext->compilerControlFlags;
+            out_ext->provokingVertexMode = in_ext->provokingVertexMode;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
         {
-            VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
+            VkDepthBiasRepresentationInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDepthBiasRepresentationInfoEXT32 *in_ext = (const VkDepthBiasRepresentationInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->libraryCount = in_ext->libraryCount;
-            out_ext->pLibraries = in_ext->pLibraries;
+            out_ext->depthBiasRepresentation = in_ext->depthBiasRepresentation;
+            out_ext->depthBiasExact = in_ext->depthBiasExact;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
-        {
-            VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineFragmentShadingRateStateCreateInfoKHR *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->fragmentSize = in_ext->fragmentSize;
-            memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
+        default:
+            FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
+    }
+}
+
+static const VkPipelineRasterizationStateCreateInfo *convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, uint32_t count)
+{
+    VkPipelineRasterizationStateCreateInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, VkPipelineMultisampleStateCreateInfo *out)
+{
+    const VkBaseInStructure32 *in_header;
+    VkBaseOutStructure *out_header = (void *)out;
+
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->flags = in->flags;
+    out->rasterizationSamples = in->rasterizationSamples;
+    out->sampleShadingEnable = in->sampleShadingEnable;
+    out->minSampleShading = in->minSampleShading;
+    out->pSampleMask = UlongToPtr(in->pSampleMask);
+    out->alphaToCoverageEnable = in->alphaToCoverageEnable;
+    out->alphaToOneEnable = in->alphaToOneEnable;
+
+    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+    {
+        switch (in_header->sType)
         {
-            VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+        {
+            VkPipelineCoverageToColorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCoverageToColorStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageToColorStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->shadingRateType = in_ext->shadingRateType;
-            out_ext->shadingRate = in_ext->shadingRate;
-            memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
+            out_ext->flags = in_ext->flags;
+            out_ext->coverageToColorEnable = in_ext->coverageToColorEnable;
+            out_ext->coverageToColorLocation = in_ext->coverageToColorLocation;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
         {
-            VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRenderingCreateInfo *in_ext = (const VkPipelineRenderingCreateInfo *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
+            VkPipelineSampleLocationsStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineSampleLocationsStateCreateInfoEXT32 *in_ext = (const VkPipelineSampleLocationsStateCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->viewMask = in_ext->viewMask;
-            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
-            out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats;
-            out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
-            out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
+            out_ext->sampleLocationsEnable = in_ext->sampleLocationsEnable;
+            convert_VkSampleLocationsInfoEXT_win32_to_host(&in_ext->sampleLocationsInfo, &out_ext->sampleLocationsInfo);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
         {
-            VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
+            VkPipelineCoverageModulationStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCoverageModulationStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageModulationStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
-            out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
-            out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
+            out_ext->flags = in_ext->flags;
+            out_ext->coverageModulationMode = in_ext->coverageModulationMode;
+            out_ext->coverageModulationTableEnable = in_ext->coverageModulationTableEnable;
+            out_ext->coverageModulationTableCount = in_ext->coverageModulationTableCount;
+            out_ext->pCoverageModulationTable = UlongToPtr(in_ext->pCoverageModulationTable);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
         {
-            VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
+            VkPipelineCoverageReductionStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCoverageReductionStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageReductionStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV;
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
+            out_ext->coverageReductionMode = in_ext->coverageReductionMode;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
-        {
-            VkPipelineRobustnessCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRobustnessCreateInfo *in_ext = (const VkPipelineRobustnessCreateInfo *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO;
-            out_ext->pNext = NULL;
-            out_ext->storageBuffers = in_ext->storageBuffers;
-            out_ext->uniformBuffers = in_ext->uniformBuffers;
-            out_ext->vertexInputs = in_ext->vertexInputs;
-            out_ext->images = in_ext->images;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
+        default:
+            FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
         }
-        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO:
+    }
+}
+
+static const VkPipelineMultisampleStateCreateInfo *convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, uint32_t count)
+{
+    VkPipelineMultisampleStateCreateInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(const VkPipelineDepthStencilStateCreateInfo32 *in, VkPipelineDepthStencilStateCreateInfo *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->flags = in->flags;
+    out->depthTestEnable = in->depthTestEnable;
+    out->depthWriteEnable = in->depthWriteEnable;
+    out->depthCompareOp = in->depthCompareOp;
+    out->depthBoundsTestEnable = in->depthBoundsTestEnable;
+    out->stencilTestEnable = in->stencilTestEnable;
+    out->front = in->front;
+    out->back = in->back;
+    out->minDepthBounds = in->minDepthBounds;
+    out->maxDepthBounds = in->maxDepthBounds;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static const VkPipelineDepthStencilStateCreateInfo *convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDepthStencilStateCreateInfo32 *in, uint32_t count)
+{
+    VkPipelineDepthStencilStateCreateInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, VkPipelineColorBlendStateCreateInfo *out)
+{
+    const VkBaseInStructure32 *in_header;
+    VkBaseOutStructure *out_header = (void *)out;
+
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->flags = in->flags;
+    out->logicOpEnable = in->logicOpEnable;
+    out->logicOp = in->logicOp;
+    out->attachmentCount = in->attachmentCount;
+    out->pAttachments = UlongToPtr(in->pAttachments);
+    memcpy(out->blendConstants, in->blendConstants, 4 * sizeof(float));
+
+    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+    {
+        switch (in_header->sType)
         {
-            VkRenderingAttachmentLocationInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRenderingAttachmentLocationInfo *in_ext = (const VkRenderingAttachmentLocationInfo *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO;
-            out_ext->pNext = NULL;
-            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
-            out_ext->pColorAttachmentLocations = in_ext->pColorAttachmentLocations;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO:
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
         {
-            VkRenderingInputAttachmentIndexInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRenderingInputAttachmentIndexInfo *in_ext = (const VkRenderingInputAttachmentIndexInfo *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO;
+            VkPipelineColorBlendAdvancedStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *in_ext = (const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
-            out_ext->pColorAttachmentInputIndices = in_ext->pColorAttachmentInputIndices;
-            out_ext->pDepthInputAttachmentIndex = in_ext->pDepthInputAttachmentIndex;
-            out_ext->pStencilInputAttachmentIndex = in_ext->pStencilInputAttachmentIndex;
+            out_ext->srcPremultiplied = in_ext->srcPremultiplied;
+            out_ext->dstPremultiplied = in_ext->dstPremultiplied;
+            out_ext->blendOverlap = in_ext->blendOverlap;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE:
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
         {
-            VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE;
+            VkPipelineColorWriteCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineColorWriteCreateInfoEXT32 *in_ext = (const VkPipelineColorWriteCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers;
+            out_ext->attachmentCount = in_ext->attachmentCount;
+            out_ext->pColorWriteEnables = UlongToPtr(in_ext->pColorWriteEnables);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22987,9 +22925,83 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct con
         }
     }
 }
-#endif /* _WIN64 */

-static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, VkGraphicsPipelineCreateInfo *out)
+static const VkPipelineColorBlendStateCreateInfo *convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, uint32_t count)
+{
+    VkPipelineColorBlendStateCreateInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkPipelineDynamicStateCreateInfo_win32_to_host(const VkPipelineDynamicStateCreateInfo32 *in, VkPipelineDynamicStateCreateInfo *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->flags = in->flags;
+    out->dynamicStateCount = in->dynamicStateCount;
+    out->pDynamicStates = UlongToPtr(in->pDynamicStates);
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static const VkPipelineDynamicStateCreateInfo *convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDynamicStateCreateInfo32 *in, uint32_t count)
+{
+    VkPipelineDynamicStateCreateInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkPipelineDynamicStateCreateInfo_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, VkGraphicsShaderGroupCreateInfoNV *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->stageCount = in->stageCount;
+    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
+    out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1);
+    out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1);
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, uint32_t count)
+{
+    VkGraphicsShaderGroupCreateInfoNV *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, VkGraphicsPipelineCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -23240,7 +23252,23 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct con
     }
 }

-static inline void convert_VkGraphicsPipelineCreateInfo_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out)
+static const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, uint32_t count)
+{
+    VkGraphicsPipelineCreateInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkGraphicsPipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkGraphicsPipelineCreateInfo_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -23268,41 +23296,7 @@ static inline void convert_VkGraphicsPipelineCreateInfo_host_to_win32(const VkGr
     }
 }

-#ifdef _WIN64
-static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, uint32_t count)
-{
-    VkGraphicsPipelineCreateInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkGraphicsPipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-#endif /* _WIN64 */
-
-static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, uint32_t count)
-{
-    VkGraphicsPipelineCreateInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkGraphicsPipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out, uint32_t count)
+static void convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out, uint32_t count)
 {
     unsigned int i;

@@ -23315,7 +23309,7 @@ static inline void convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(cons
 }

#ifdef _WIN64
-static inline void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkImageCreateInfo *in, VkImageCreateInfo *out)
+static void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkImageCreateInfo *in, VkImageCreateInfo *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -23464,7 +23458,7 @@ static inline void convert_VkImageCreateInfo_win64_to_host(struct conversion_con
 }
 #endif /* _WIN64 */

-static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, VkImageCreateInfo *out)
+static void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, VkImageCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -23612,7 +23606,7 @@ static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_con
     }
 }

-static inline void convert_VkImageViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageViewCreateInfo32 *in, VkImageViewCreateInfo *out)
+static void convert_VkImageViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageViewCreateInfo32 *in, VkImageViewCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -23719,7 +23713,7 @@ static inline void convert_VkImageViewCreateInfo_win32_to_host(struct conversion
     }
 }

-static inline void convert_VkIndirectCommandsTokenDataEXT_win32_to_host(const VkIndirectCommandsTokenDataEXT32 *in, VkIndirectCommandsTokenDataEXT *out, VkFlags selector)
+static void convert_VkIndirectCommandsTokenDataEXT_win32_to_host(const VkIndirectCommandsTokenDataEXT32 *in, VkIndirectCommandsTokenDataEXT *out, VkFlags selector)
 {
     if (!in) return;

@@ -23733,7 +23727,7 @@ static inline void convert_VkIndirectCommandsTokenDataEXT_win32_to_host(const Vk
         out->pExecutionSet = UlongToPtr(in->pExecutionSet);
 }

-static inline void convert_VkIndirectCommandsLayoutTokenEXT_win32_to_host(const VkIndirectCommandsLayoutTokenEXT32 *in, VkIndirectCommandsLayoutTokenEXT *out)
+static void convert_VkIndirectCommandsLayoutTokenEXT_win32_to_host(const VkIndirectCommandsLayoutTokenEXT32 *in, VkIndirectCommandsLayoutTokenEXT *out)
 {
     if (!in) return;

@@ -23746,7 +23740,7 @@ static inline void convert_VkIndirectCommandsLayoutTokenEXT_win32_to_host(const
         FIXME("Unexpected pNext\n");
 }

-static inline const VkIndirectCommandsLayoutTokenEXT *convert_VkIndirectCommandsLayoutTokenEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenEXT32 *in, uint32_t count)
+static const VkIndirectCommandsLayoutTokenEXT *convert_VkIndirectCommandsLayoutTokenEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenEXT32 *in, uint32_t count)
 {
     VkIndirectCommandsLayoutTokenEXT *out;
     unsigned int i;
@@ -23762,7 +23756,7 @@ static inline const VkIndirectCommandsLayoutTokenEXT *convert_VkIndirectCommands
     return out;
 }

-static inline void convert_VkIndirectCommandsLayoutCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoEXT32 *in, VkIndirectCommandsLayoutCreateInfoEXT *out)
+static void convert_VkIndirectCommandsLayoutCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoEXT32 *in, VkIndirectCommandsLayoutCreateInfoEXT *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -23804,7 +23798,7 @@ static inline void convert_VkIndirectCommandsLayoutCreateInfoEXT_win32_to_host(s
     }
 }

-static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const VkIndirectCommandsLayoutTokenNV32 *in, VkIndirectCommandsLayoutTokenNV *out)
+static void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const VkIndirectCommandsLayoutTokenNV32 *in, VkIndirectCommandsLayoutTokenNV *out)
 {
     if (!in) return;

@@ -23827,7 +23821,7 @@ static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const V
         FIXME("Unexpected pNext\n");
 }

-static inline const VkIndirectCommandsLayoutTokenNV *convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenNV32 *in, uint32_t count)
+static const VkIndirectCommandsLayoutTokenNV *convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenNV32 *in, uint32_t count)
 {
     VkIndirectCommandsLayoutTokenNV *out;
     unsigned int i;
@@ -23843,7 +23837,7 @@ static inline const VkIndirectCommandsLayoutTokenNV *convert_VkIndirectCommandsL
     return out;
 }

-static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoNV32 *in, VkIndirectCommandsLayoutCreateInfoNV *out)
+static void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoNV32 *in, VkIndirectCommandsLayoutCreateInfoNV *out)
 {
     if (!in) return;

@@ -23859,7 +23853,7 @@ static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(st
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkIndirectExecutionSetPipelineInfoEXT_win32_to_host(const VkIndirectExecutionSetPipelineInfoEXT32 *in, VkIndirectExecutionSetPipelineInfoEXT *out)
+static void convert_VkIndirectExecutionSetPipelineInfoEXT_win32_to_host(const VkIndirectExecutionSetPipelineInfoEXT32 *in, VkIndirectExecutionSetPipelineInfoEXT *out)
 {
     if (!in) return;

@@ -23871,7 +23865,7 @@ static inline void convert_VkIndirectExecutionSetPipelineInfoEXT_win32_to_host(c
         FIXME("Unexpected pNext\n");
 }

-static inline const VkIndirectExecutionSetPipelineInfoEXT *convert_VkIndirectExecutionSetPipelineInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetPipelineInfoEXT32 *in, uint32_t count)
+static const VkIndirectExecutionSetPipelineInfoEXT *convert_VkIndirectExecutionSetPipelineInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetPipelineInfoEXT32 *in, uint32_t count)
 {
     VkIndirectExecutionSetPipelineInfoEXT *out;
     unsigned int i;
@@ -23887,7 +23881,7 @@ static inline const VkIndirectExecutionSetPipelineInfoEXT *convert_VkIndirectExe
     return out;
 }

-static inline void convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_host(const VkIndirectExecutionSetShaderLayoutInfoEXT32 *in, VkIndirectExecutionSetShaderLayoutInfoEXT *out)
+static void convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_host(const VkIndirectExecutionSetShaderLayoutInfoEXT32 *in, VkIndirectExecutionSetShaderLayoutInfoEXT *out)
 {
     if (!in) return;

@@ -23895,94 +23889,13 @@ static inline void convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_ho
     out->pNext = NULL;
     out->setLayoutCount = in->setLayoutCount;
     out->pSetLayouts = UlongToPtr(in->pSetLayouts);
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
-}
-
-static inline const VkIndirectExecutionSetShaderLayoutInfoEXT *convert_VkIndirectExecutionSetShaderLayoutInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderLayoutInfoEXT32 *in, uint32_t count)
-{
-    VkIndirectExecutionSetShaderLayoutInfoEXT *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_host(&in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkIndirectExecutionSetShaderInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderInfoEXT32 *in, VkIndirectExecutionSetShaderInfoEXT *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->shaderCount = in->shaderCount;
-    out->pInitialShaders = UlongToPtr(in->pInitialShaders);
-    out->pSetLayoutInfos = convert_VkIndirectExecutionSetShaderLayoutInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetShaderLayoutInfoEXT32 *)UlongToPtr(in->pSetLayoutInfos), in->shaderCount);
-    out->maxShaderCount = in->maxShaderCount;
-    out->pushConstantRangeCount = in->pushConstantRangeCount;
-    out->pPushConstantRanges = UlongToPtr(in->pPushConstantRanges);
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
-}
-
-static inline const VkIndirectExecutionSetShaderInfoEXT *convert_VkIndirectExecutionSetShaderInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderInfoEXT32 *in, uint32_t count)
-{
-    VkIndirectExecutionSetShaderInfoEXT *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkIndirectExecutionSetShaderInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkIndirectExecutionSetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetInfoEXT32 *in, VkIndirectExecutionSetInfoEXT *out, VkFlags selector)
-{
-    if (!in) return;
-
-    if (selector == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT)
-        out->pPipelineInfo = convert_VkIndirectExecutionSetPipelineInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetPipelineInfoEXT32 *)UlongToPtr(in->pPipelineInfo), 1);
-    if (selector == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT)
-        out->pShaderInfo = convert_VkIndirectExecutionSetShaderInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetShaderInfoEXT32 *)UlongToPtr(in->pShaderInfo), 1);
-}
-
-static inline void convert_VkIndirectExecutionSetCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetCreateInfoEXT32 *in, VkIndirectExecutionSetCreateInfoEXT *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->type = in->type;
-    convert_VkIndirectExecutionSetInfoEXT_win32_to_host(ctx, &in->info, &out->info, in->type);
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
-}
-
-static inline void convert_VkLayerSettingEXT_win32_to_host(const VkLayerSettingEXT32 *in, VkLayerSettingEXT *out)
-{
-    if (!in) return;
-
-    out->pLayerName = UlongToPtr(in->pLayerName);
-    out->pSettingName = UlongToPtr(in->pSettingName);
-    out->type = in->type;
-    out->valueCount = in->valueCount;
-    out->pValues = UlongToPtr(in->pValues);
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
 }

-static inline const VkLayerSettingEXT *convert_VkLayerSettingEXT_array_win32_to_host(struct conversion_context *ctx, const VkLayerSettingEXT32 *in, uint32_t count)
+static const VkIndirectExecutionSetShaderLayoutInfoEXT *convert_VkIndirectExecutionSetShaderLayoutInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderLayoutInfoEXT32 *in, uint32_t count)
 {
-    VkLayerSettingEXT *out;
+    VkIndirectExecutionSetShaderLayoutInfoEXT *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -23990,30 +23903,31 @@ static inline const VkLayerSettingEXT *convert_VkLayerSettingEXT_array_win32_to_
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkLayerSettingEXT_win32_to_host(&in[i], &out[i]);
+        convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_host(&in[i], &out[i]);
     }

return out;
 }

-static inline void convert_VkApplicationInfo_win32_to_host(const VkApplicationInfo32 *in, VkApplicationInfo *out)
+static void convert_VkIndirectExecutionSetShaderInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderInfoEXT32 *in, VkIndirectExecutionSetShaderInfoEXT *out)
 {
     if (!in) return;

out->sType = in->sType;
     out->pNext = NULL;
-    out->pApplicationName = UlongToPtr(in->pApplicationName);
-    out->applicationVersion = in->applicationVersion;
-    out->pEngineName = UlongToPtr(in->pEngineName);
-    out->engineVersion = in->engineVersion;
-    out->apiVersion = in->apiVersion;
+    out->shaderCount = in->shaderCount;
+    out->pInitialShaders = UlongToPtr(in->pInitialShaders);
+    out->pSetLayoutInfos = convert_VkIndirectExecutionSetShaderLayoutInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetShaderLayoutInfoEXT32 *)UlongToPtr(in->pSetLayoutInfos), in->shaderCount);
+    out->maxShaderCount = in->maxShaderCount;
+    out->pushConstantRangeCount = in->pushConstantRangeCount;
+    out->pPushConstantRanges = UlongToPtr(in->pPushConstantRanges);
     if (in->pNext)
         FIXME("Unexpected pNext\n");
 }

-static inline const VkApplicationInfo *convert_VkApplicationInfo_array_win32_to_host(struct conversion_context *ctx, const VkApplicationInfo32 *in, uint32_t count)
+static const VkIndirectExecutionSetShaderInfoEXT *convert_VkIndirectExecutionSetShaderInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderInfoEXT32 *in, uint32_t count)
 {
-    VkApplicationInfo *out;
+    VkIndirectExecutionSetShaderInfoEXT *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -24021,14 +23935,36 @@ static inline const VkApplicationInfo *convert_VkApplicationInfo_array_win32_to_
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkApplicationInfo_win32_to_host(&in[i], &out[i]);
+        convert_VkIndirectExecutionSetShaderInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }

+static void convert_VkIndirectExecutionSetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetInfoEXT32 *in, VkIndirectExecutionSetInfoEXT *out, VkFlags selector)
+{
+    if (!in) return;
+
+    if (selector == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT)
+        out->pPipelineInfo = convert_VkIndirectExecutionSetPipelineInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetPipelineInfoEXT32 *)UlongToPtr(in->pPipelineInfo), 1);
+    if (selector == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT)
+        out->pShaderInfo = convert_VkIndirectExecutionSetShaderInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetShaderInfoEXT32 *)UlongToPtr(in->pShaderInfo), 1);
+}
+
+static void convert_VkIndirectExecutionSetCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetCreateInfoEXT32 *in, VkIndirectExecutionSetCreateInfoEXT *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->type = in->type;
+    convert_VkIndirectExecutionSetInfoEXT_win32_to_host(ctx, &in->info, &out->info, in->type);
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
 #ifdef _WIN64
-static inline void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo *in, VkInstanceCreateInfo *out)
+static void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo *in, VkInstanceCreateInfo *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -24124,7 +24060,65 @@ static inline void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_
 }
 #endif /* _WIN64 */

-static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo32 *in, VkInstanceCreateInfo *out)
+static void convert_VkApplicationInfo_win32_to_host(const VkApplicationInfo32 *in, VkApplicationInfo *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->pApplicationName = UlongToPtr(in->pApplicationName);
+    out->applicationVersion = in->applicationVersion;
+    out->pEngineName = UlongToPtr(in->pEngineName);
+    out->engineVersion = in->engineVersion;
+    out->apiVersion = in->apiVersion;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static const VkApplicationInfo *convert_VkApplicationInfo_array_win32_to_host(struct conversion_context *ctx, const VkApplicationInfo32 *in, uint32_t count)
+{
+    VkApplicationInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkApplicationInfo_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkLayerSettingEXT_win32_to_host(const VkLayerSettingEXT32 *in, VkLayerSettingEXT *out)
+{
+    if (!in) return;
+
+    out->pLayerName = UlongToPtr(in->pLayerName);
+    out->pSettingName = UlongToPtr(in->pSettingName);
+    out->type = in->type;
+    out->valueCount = in->valueCount;
+    out->pValues = UlongToPtr(in->pValues);
+}
+
+static const VkLayerSettingEXT *convert_VkLayerSettingEXT_array_win32_to_host(struct conversion_context *ctx, const VkLayerSettingEXT32 *in, uint32_t count)
+{
+    VkLayerSettingEXT *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkLayerSettingEXT_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo32 *in, VkInstanceCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -24219,7 +24213,7 @@ static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_
     }
 }

-static inline void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicromapCreateInfoEXT32 *in, VkMicromapCreateInfoEXT *out)
+static void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicromapCreateInfoEXT32 *in, VkMicromapCreateInfoEXT *out)
 {
     if (!in) return;

@@ -24235,7 +24229,7 @@ static inline void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicroma
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowSessionCreateInfoNV32 *in, VkOpticalFlowSessionCreateInfoNV *out)
+static void convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowSessionCreateInfoNV32 *in, VkOpticalFlowSessionCreateInfoNV *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -24278,7 +24272,7 @@ static inline void convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(struct
     }
 }

-static inline void convert_VkPipelineBinaryKeyKHR_win32_to_host(const VkPipelineBinaryKeyKHR32 *in, VkPipelineBinaryKeyKHR *out)
+static void convert_VkPipelineBinaryKeyKHR_win32_to_host(const VkPipelineBinaryKeyKHR32 *in, VkPipelineBinaryKeyKHR *out)
 {
     if (!in) return;

@@ -24290,7 +24284,7 @@ static inline void convert_VkPipelineBinaryKeyKHR_win32_to_host(const VkPipeline
         FIXME("Unexpected pNext\n");
 }

-static inline const VkPipelineBinaryKeyKHR *convert_VkPipelineBinaryKeyKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeyKHR32 *in, uint32_t count)
+static const VkPipelineBinaryKeyKHR *convert_VkPipelineBinaryKeyKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeyKHR32 *in, uint32_t count)
 {
     VkPipelineBinaryKeyKHR *out;
     unsigned int i;
@@ -24306,7 +24300,7 @@ static inline const VkPipelineBinaryKeyKHR *convert_VkPipelineBinaryKeyKHR_array
     return out;
 }

-static inline void convert_VkPipelineBinaryDataKHR_win32_to_host(const VkPipelineBinaryDataKHR32 *in, VkPipelineBinaryDataKHR *out)
+static void convert_VkPipelineBinaryDataKHR_win32_to_host(const VkPipelineBinaryDataKHR32 *in, VkPipelineBinaryDataKHR *out)
 {
     if (!in) return;

@@ -24314,7 +24308,7 @@ static inline void convert_VkPipelineBinaryDataKHR_win32_to_host(const VkPipelin
     out->pData = UlongToPtr(in->pData);
 }

-static inline const VkPipelineBinaryDataKHR *convert_VkPipelineBinaryDataKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryDataKHR32 *in, uint32_t count)
+static const VkPipelineBinaryDataKHR *convert_VkPipelineBinaryDataKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryDataKHR32 *in, uint32_t count)
 {
     VkPipelineBinaryDataKHR *out;
     unsigned int i;
@@ -24330,7 +24324,7 @@ static inline const VkPipelineBinaryDataKHR *convert_VkPipelineBinaryDataKHR_arr
     return out;
 }

-static inline void convert_VkPipelineBinaryKeysAndDataKHR_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeysAndDataKHR32 *in, VkPipelineBinaryKeysAndDataKHR *out)
+static void convert_VkPipelineBinaryKeysAndDataKHR_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeysAndDataKHR32 *in, VkPipelineBinaryKeysAndDataKHR *out)
 {
     if (!in) return;

@@ -24339,7 +24333,7 @@ static inline void convert_VkPipelineBinaryKeysAndDataKHR_win32_to_host(struct c
     out->pPipelineBinaryData = convert_VkPipelineBinaryDataKHR_array_win32_to_host(ctx, (const VkPipelineBinaryDataKHR32 *)UlongToPtr(in->pPipelineBinaryData), in->binaryCount);
 }

-static inline const VkPipelineBinaryKeysAndDataKHR *convert_VkPipelineBinaryKeysAndDataKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeysAndDataKHR32 *in, uint32_t count)
+static const VkPipelineBinaryKeysAndDataKHR *convert_VkPipelineBinaryKeysAndDataKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeysAndDataKHR32 *in, uint32_t count)
 {
     VkPipelineBinaryKeysAndDataKHR *out;
     unsigned int i;
@@ -24355,7 +24349,7 @@ static inline const VkPipelineBinaryKeysAndDataKHR *convert_VkPipelineBinaryKeys
     return out;
 }

-static inline void convert_VkPipelineCreateInfoKHR_win32_to_host(const VkPipelineCreateInfoKHR32 *in, VkPipelineCreateInfoKHR *out)
+static void convert_VkPipelineCreateInfoKHR_win32_to_host(const VkPipelineCreateInfoKHR32 *in, VkPipelineCreateInfoKHR *out)
 {
     if (!in) return;

@@ -24365,7 +24359,7 @@ static inline void convert_VkPipelineCreateInfoKHR_win32_to_host(const VkPipelin
         FIXME("Unexpected pNext\n");
 }

-static inline const VkPipelineCreateInfoKHR *convert_VkPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreateInfoKHR32 *in, uint32_t count)
+static const VkPipelineCreateInfoKHR *convert_VkPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreateInfoKHR32 *in, uint32_t count)
 {
     VkPipelineCreateInfoKHR *out;
     unsigned int i;
@@ -24381,7 +24375,7 @@ static inline const VkPipelineCreateInfoKHR *convert_VkPipelineCreateInfoKHR_arr
     return out;
 }

-static inline void convert_VkPipelineBinaryCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryCreateInfoKHR32 *in, VkPipelineBinaryCreateInfoKHR *out)
+static void convert_VkPipelineBinaryCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryCreateInfoKHR32 *in, VkPipelineBinaryCreateInfoKHR *out)
 {
     if (!in) return;

@@ -24394,7 +24388,7 @@ static inline void convert_VkPipelineBinaryCreateInfoKHR_win32_to_host(struct co
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPipelineBinaryHandlesInfoKHR_win32_to_host(const VkPipelineBinaryHandlesInfoKHR32 *in, VkPipelineBinaryHandlesInfoKHR *out)
+static void convert_VkPipelineBinaryHandlesInfoKHR_win32_to_host(const VkPipelineBinaryHandlesInfoKHR32 *in, VkPipelineBinaryHandlesInfoKHR *out)
 {
     if (!in) return;

@@ -24406,7 +24400,7 @@ static inline void convert_VkPipelineBinaryHandlesInfoKHR_win32_to_host(const Vk
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPipelineBinaryHandlesInfoKHR_host_to_win32(const VkPipelineBinaryHandlesInfoKHR *in, VkPipelineBinaryHandlesInfoKHR32 *out)
+static void convert_VkPipelineBinaryHandlesInfoKHR_host_to_win32(const VkPipelineBinaryHandlesInfoKHR *in, VkPipelineBinaryHandlesInfoKHR32 *out)
 {
     if (!in) return;

@@ -24414,7 +24408,7 @@ static inline void convert_VkPipelineBinaryHandlesInfoKHR_host_to_win32(const Vk
     out->pPipelineBinaries = PtrToUlong(in->pPipelineBinaries);
 }

-static inline void convert_VkPipelineCacheCreateInfo_win32_to_host(const VkPipelineCacheCreateInfo32 *in, VkPipelineCacheCreateInfo *out)
+static void convert_VkPipelineCacheCreateInfo_win32_to_host(const VkPipelineCacheCreateInfo32 *in, VkPipelineCacheCreateInfo *out)
 {
     if (!in) return;

@@ -24427,7 +24421,7 @@ static inline void convert_VkPipelineCacheCreateInfo_win32_to_host(const VkPipel
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPipelineLayoutCreateInfo_win32_to_host(const VkPipelineLayoutCreateInfo32 *in, VkPipelineLayoutCreateInfo *out)
+static void convert_VkPipelineLayoutCreateInfo_win32_to_host(const VkPipelineLayoutCreateInfo32 *in, VkPipelineLayoutCreateInfo *out)
 {
     if (!in) return;

@@ -24442,7 +24436,7 @@ static inline void convert_VkPipelineLayoutCreateInfo_win32_to_host(const VkPipe
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPrivateDataSlotCreateInfo_win32_to_host(const VkPrivateDataSlotCreateInfo32 *in, VkPrivateDataSlotCreateInfo *out)
+static void convert_VkPrivateDataSlotCreateInfo_win32_to_host(const VkPrivateDataSlotCreateInfo32 *in, VkPrivateDataSlotCreateInfo *out)
 {
     if (!in) return;

@@ -24453,7 +24447,7 @@ static inline void convert_VkPrivateDataSlotCreateInfo_win32_to_host(const VkPri
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkQueryPoolCreateInfo32 *in, VkQueryPoolCreateInfo *out)
+static void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkQueryPoolCreateInfo32 *in, VkQueryPoolCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -24608,7 +24602,47 @@ static inline void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion
     }
 }

-static inline void convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(const VkRayTracingShaderGroupCreateInfoKHR32 *in, VkRayTracingShaderGroupCreateInfoKHR *out)
+#ifdef _WIN64
+static void convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, VkRayTracingPipelineCreateInfoKHR *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->flags = in->flags;
+    out->stageCount = in->stageCount;
+    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
+    out->groupCount = in->groupCount;
+    out->pGroups = in->pGroups;
+    out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
+    out->pLibraryInfo = in->pLibraryInfo;
+    out->pLibraryInterface = in->pLibraryInterface;
+    out->pDynamicState = in->pDynamicState;
+    out->layout = in->layout;
+    out->basePipelineHandle = in->basePipelineHandle;
+    out->basePipelineIndex = in->basePipelineIndex;
+}
+#endif /* _WIN64 */
+
+#ifdef _WIN64
+static const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, uint32_t count)
+{
+    VkRayTracingPipelineCreateInfoKHR *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+#endif /* _WIN64 */
+
+static void convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(const VkRayTracingShaderGroupCreateInfoKHR32 *in, VkRayTracingShaderGroupCreateInfoKHR *out)
 {
     if (!in) return;

@@ -24624,7 +24658,7 @@ static inline void convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(co
         FIXME("Unexpected pNext\n");
 }

-static inline const VkRayTracingShaderGroupCreateInfoKHR *convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoKHR32 *in, uint32_t count)
+static const VkRayTracingShaderGroupCreateInfoKHR *convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoKHR32 *in, uint32_t count)
 {
     VkRayTracingShaderGroupCreateInfoKHR *out;
     unsigned int i;
@@ -24640,7 +24674,7 @@ static inline const VkRayTracingShaderGroupCreateInfoKHR *convert_VkRayTracingSh
     return out;
 }

-static inline void convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(const VkPipelineLibraryCreateInfoKHR32 *in, VkPipelineLibraryCreateInfoKHR *out)
+static void convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(const VkPipelineLibraryCreateInfoKHR32 *in, VkPipelineLibraryCreateInfoKHR *out)
 {
     if (!in) return;

@@ -24652,7 +24686,7 @@ static inline void convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(const Vk
         FIXME("Unexpected pNext\n");
 }

-static inline const VkPipelineLibraryCreateInfoKHR *convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineLibraryCreateInfoKHR32 *in, uint32_t count)
+static const VkPipelineLibraryCreateInfoKHR *convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineLibraryCreateInfoKHR32 *in, uint32_t count)
 {
     VkPipelineLibraryCreateInfoKHR *out;
     unsigned int i;
@@ -24668,7 +24702,7 @@ static inline const VkPipelineLibraryCreateInfoKHR *convert_VkPipelineLibraryCre
     return out;
 }

-static inline void convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, VkRayTracingPipelineInterfaceCreateInfoKHR *out)
+static void convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, VkRayTracingPipelineInterfaceCreateInfoKHR *out)
 {
     if (!in) return;

@@ -24680,7 +24714,7 @@ static inline void convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_h
         FIXME("Unexpected pNext\n");
 }

-static inline const VkRayTracingPipelineInterfaceCreateInfoKHR *convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, uint32_t count)
+static const VkRayTracingPipelineInterfaceCreateInfoKHR *convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, uint32_t count)
 {
     VkRayTracingPipelineInterfaceCreateInfoKHR *out;
     unsigned int i;
@@ -24696,29 +24730,7 @@ static inline const VkRayTracingPipelineInterfaceCreateInfoKHR *convert_VkRayTra
     return out;
 }

-#ifdef _WIN64
-static inline void convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, VkRayTracingPipelineCreateInfoKHR *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->flags = in->flags;
-    out->stageCount = in->stageCount;
-    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
-    out->groupCount = in->groupCount;
-    out->pGroups = in->pGroups;
-    out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
-    out->pLibraryInfo = in->pLibraryInfo;
-    out->pLibraryInterface = in->pLibraryInterface;
-    out->pDynamicState = in->pDynamicState;
-    out->layout = in->layout;
-    out->basePipelineHandle = in->basePipelineHandle;
-    out->basePipelineIndex = in->basePipelineIndex;
-}
-#endif /* _WIN64 */
-
-static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, VkRayTracingPipelineCreateInfoKHR *out)
+static void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, VkRayTracingPipelineCreateInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -24812,7 +24824,23 @@ static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struc
     }
 }

-static inline void convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out)
+static const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, uint32_t count)
+{
+    VkRayTracingPipelineCreateInfoKHR *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -24840,27 +24868,41 @@ static inline void convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(const
     }
 }

-#ifdef _WIN64
-static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, uint32_t count)
+static void convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out, uint32_t count)
 {
-    VkRayTracingPipelineCreateInfoKHR *out;
     unsigned int i;

-    if (!in || !count) return NULL;
+    if (!in) return;

-    out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(ctx, &in[i], &out[i]);
+        convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(&in[i], &out[i]);
     }
+}

-    return out;
+#ifdef _WIN64
+static void convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, VkRayTracingPipelineCreateInfoNV *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->flags = in->flags;
+    out->stageCount = in->stageCount;
+    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
+    out->groupCount = in->groupCount;
+    out->pGroups = in->pGroups;
+    out->maxRecursionDepth = in->maxRecursionDepth;
+    out->layout = in->layout;
+    out->basePipelineHandle = in->basePipelineHandle;
+    out->basePipelineIndex = in->basePipelineIndex;
 }
 #endif /* _WIN64 */

-static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, uint32_t count)
+#ifdef _WIN64
+static const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, uint32_t count)
 {
-    VkRayTracingPipelineCreateInfoKHR *out;
+    VkRayTracingPipelineCreateInfoNV *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -24868,25 +24910,14 @@ static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipel
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
+        convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
+#endif /* _WIN64 */

-static inline void convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out, uint32_t count)
-{
-    unsigned int i;
-
-    if (!in) return;
-
-    for (i = 0; i < count; i++)
-    {
-        convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(&in[i], &out[i]);
-    }
-}
-
-static inline void convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(const VkRayTracingShaderGroupCreateInfoNV32 *in, VkRayTracingShaderGroupCreateInfoNV *out)
+static void convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(const VkRayTracingShaderGroupCreateInfoNV32 *in, VkRayTracingShaderGroupCreateInfoNV *out)
 {
     if (!in) return;

@@ -24901,7 +24932,7 @@ static inline void convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(con
         FIXME("Unexpected pNext\n");
 }

-static inline const VkRayTracingShaderGroupCreateInfoNV *convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoNV32 *in, uint32_t count)
+static const VkRayTracingShaderGroupCreateInfoNV *convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoNV32 *in, uint32_t count)
 {
     VkRayTracingShaderGroupCreateInfoNV *out;
     unsigned int i;
@@ -24917,26 +24948,7 @@ static inline const VkRayTracingShaderGroupCreateInfoNV *convert_VkRayTracingSha
     return out;
 }

-#ifdef _WIN64
-static inline void convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, VkRayTracingPipelineCreateInfoNV *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->flags = in->flags;
-    out->stageCount = in->stageCount;
-    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
-    out->groupCount = in->groupCount;
-    out->pGroups = in->pGroups;
-    out->maxRecursionDepth = in->maxRecursionDepth;
-    out->layout = in->layout;
-    out->basePipelineHandle = in->basePipelineHandle;
-    out->basePipelineIndex = in->basePipelineIndex;
-}
-#endif /* _WIN64 */
-
-static inline void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, VkRayTracingPipelineCreateInfoNV *out)
+static void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, VkRayTracingPipelineCreateInfoNV *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -24984,42 +24996,13 @@ static inline void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct
             break;
         }
         default:
-            FIXME("Unhandled sType %u.\n", in_header->sType);
-            break;
-        }
-    }
-}
-
-static inline void convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out)
-{
-    const VkBaseInStructure *in_header;
-    VkBaseOutStructure32 *out_header = (void *)out;
-
-    if (!in) return;
-
-
-    for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
-    {
-        switch (in_header->sType)
-        {
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
-        {
-            VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
-            const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
-            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
-            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
-            out_header = (void *)out_ext;
-            break;
-        }
-        default:
+            FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
         }
     }
 }

-#ifdef _WIN64
-static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, uint32_t count)
+static const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, uint32_t count)
 {
     VkRayTracingPipelineCreateInfoNV *out;
     unsigned int i;
@@ -25029,30 +25012,41 @@ static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipeli
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
+        convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
-#endif /* _WIN64 */

-static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, uint32_t count)
+static void convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out)
 {
-    VkRayTracingPipelineCreateInfoNV *out;
-    unsigned int i;
+    const VkBaseInStructure *in_header;
+    VkBaseOutStructure32 *out_header = (void *)out;

-    if (!in || !count) return NULL;
+    if (!in) return;

-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
+
+    for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
     {
-        convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
+        switch (in_header->sType)
+        {
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+        {
+            VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
+            const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
+            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
+            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
+            out_header = (void *)out_ext;
+            break;
+        }
+        default:
+            break;
+        }
     }
-
-    return out;
 }

-static inline void convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out, uint32_t count)
+static void convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out, uint32_t count)
 {
     unsigned int i;

@@ -25064,7 +25058,7 @@ static inline void convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(
     }
 }

-static inline void convert_VkSubpassDescription_win32_to_host(const VkSubpassDescription32 *in, VkSubpassDescription *out)
+static void convert_VkSubpassDescription_win32_to_host(const VkSubpassDescription32 *in, VkSubpassDescription *out)
 {
     if (!in) return;

@@ -25080,7 +25074,7 @@ static inline void convert_VkSubpassDescription_win32_to_host(const VkSubpassDes
     out->pPreserveAttachments = UlongToPtr(in->pPreserveAttachments);
 }

-static inline const VkSubpassDescription *convert_VkSubpassDescription_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription32 *in, uint32_t count)
+static const VkSubpassDescription *convert_VkSubpassDescription_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription32 *in, uint32_t count)
 {
     VkSubpassDescription *out;
     unsigned int i;
@@ -25096,7 +25090,7 @@ static inline const VkSubpassDescription *convert_VkSubpassDescription_array_win
     return out;
 }

-static inline void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo32 *in, VkRenderPassCreateInfo *out)
+static void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo32 *in, VkRenderPassCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -25186,7 +25180,7 @@ static inline void convert_VkRenderPassCreateInfo_win32_to_host(struct conversio
     }
 }

-static inline void convert_VkAttachmentDescription2_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, VkAttachmentDescription2 *out)
+static void convert_VkAttachmentDescription2_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, VkAttachmentDescription2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -25228,7 +25222,7 @@ static inline void convert_VkAttachmentDescription2_win32_to_host(struct convers
     }
 }

-static inline const VkAttachmentDescription2 *convert_VkAttachmentDescription2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, uint32_t count)
+static const VkAttachmentDescription2 *convert_VkAttachmentDescription2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, uint32_t count)
 {
     VkAttachmentDescription2 *out;
     unsigned int i;
@@ -25244,7 +25238,7 @@ static inline const VkAttachmentDescription2 *convert_VkAttachmentDescription2_a
     return out;
 }

-static inline void convert_VkAttachmentReference2_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, VkAttachmentReference2 *out)
+static void convert_VkAttachmentReference2_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, VkAttachmentReference2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -25279,7 +25273,7 @@ static inline void convert_VkAttachmentReference2_win32_to_host(struct conversio
     }
 }

-static inline const VkAttachmentReference2 *convert_VkAttachmentReference2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, uint32_t count)
+static const VkAttachmentReference2 *convert_VkAttachmentReference2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, uint32_t count)
 {
     VkAttachmentReference2 *out;
     unsigned int i;
@@ -25295,7 +25289,7 @@ static inline const VkAttachmentReference2 *convert_VkAttachmentReference2_array
     return out;
 }

-static inline void convert_VkSubpassDescription2_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, VkSubpassDescription2 *out)
+static void convert_VkSubpassDescription2_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, VkSubpassDescription2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -25386,7 +25380,7 @@ static inline void convert_VkSubpassDescription2_win32_to_host(struct conversion
     }
 }

-static inline const VkSubpassDescription2 *convert_VkSubpassDescription2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, uint32_t count)
+static const VkSubpassDescription2 *convert_VkSubpassDescription2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, uint32_t count)
 {
     VkSubpassDescription2 *out;
     unsigned int i;
@@ -25402,7 +25396,7 @@ static inline const VkSubpassDescription2 *convert_VkSubpassDescription2_array_w
     return out;
 }

-static inline void convert_VkSubpassDependency2_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, VkSubpassDependency2 *out)
+static void convert_VkSubpassDependency2_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, VkSubpassDependency2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -25457,7 +25451,7 @@ static inline void convert_VkSubpassDependency2_win32_to_host(struct conversion_
     }
 }

-static inline const VkSubpassDependency2 *convert_VkSubpassDependency2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, uint32_t count)
+static const VkSubpassDependency2 *convert_VkSubpassDependency2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, uint32_t count)
 {
     VkSubpassDependency2 *out;
     unsigned int i;
@@ -25473,7 +25467,7 @@ static inline const VkSubpassDependency2 *convert_VkSubpassDependency2_array_win
     return out;
 }

-static inline void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo232 *in, VkRenderPassCreateInfo2 *out)
+static void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo232 *in, VkRenderPassCreateInfo2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -25559,7 +25553,7 @@ static inline void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversi
     }
 }

-static inline void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerCreateInfo32 *in, VkSamplerCreateInfo *out)
+static void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerCreateInfo32 *in, VkSamplerCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -25676,7 +25670,7 @@ static inline void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_c
     }
 }

-static inline void convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerYcbcrConversionCreateInfo32 *in, VkSamplerYcbcrConversionCreateInfo *out)
+static void convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerYcbcrConversionCreateInfo32 *in, VkSamplerYcbcrConversionCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -25717,7 +25711,7 @@ static inline void convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(stru
     }
 }

-static inline void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSemaphoreCreateInfo32 *in, VkSemaphoreCreateInfo *out)
+static void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSemaphoreCreateInfo32 *in, VkSemaphoreCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -25773,7 +25767,7 @@ static inline void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion
     }
 }

-static inline void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_context *ctx, const VkShaderModuleCreateInfo32 *in, VkShaderModuleCreateInfo *out)
+static void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_context *ctx, const VkShaderModuleCreateInfo32 *in, VkShaderModuleCreateInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -25822,7 +25816,7 @@ static inline void convert_VkShaderModuleCreateInfo_win32_to_host(struct convers
     }
 }

-static inline void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, VkShaderCreateInfoEXT *out)
+static void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, VkShaderCreateInfoEXT *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -25880,7 +25874,7 @@ static inline void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion
     }
 }

-static inline const VkShaderCreateInfoEXT *convert_VkShaderCreateInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, uint32_t count)
+static const VkShaderCreateInfoEXT *convert_VkShaderCreateInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, uint32_t count)
 {
     VkShaderCreateInfoEXT *out;
     unsigned int i;
@@ -25896,7 +25890,7 @@ static inline const VkShaderCreateInfoEXT *convert_VkShaderCreateInfoEXT_array_w
     return out;
 }

-static inline void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkSwapchainCreateInfoKHR32 *in, VkSwapchainCreateInfoKHR *out)
+static void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkSwapchainCreateInfoKHR32 *in, VkSwapchainCreateInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -26016,7 +26010,7 @@ static inline void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(stru
     }
 }

-static inline void convert_VkTensorDescriptionARM_win32_to_host(const VkTensorDescriptionARM32 *in, VkTensorDescriptionARM *out)
+static void convert_VkTensorDescriptionARM_win32_to_host(const VkTensorDescriptionARM32 *in, VkTensorDescriptionARM *out)
 {
     if (!in) return;

@@ -26032,7 +26026,7 @@ static inline void convert_VkTensorDescriptionARM_win32_to_host(const VkTensorDe
         FIXME("Unexpected pNext\n");
 }

-static inline const VkTensorDescriptionARM *convert_VkTensorDescriptionARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorDescriptionARM32 *in, uint32_t count)
+static const VkTensorDescriptionARM *convert_VkTensorDescriptionARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorDescriptionARM32 *in, uint32_t count)
 {
     VkTensorDescriptionARM *out;
     unsigned int i;
@@ -26048,7 +26042,7 @@ static inline const VkTensorDescriptionARM *convert_VkTensorDescriptionARM_array
     return out;
 }

-static inline void convert_VkTensorCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkTensorCreateInfoARM32 *in, VkTensorCreateInfoARM *out)
+static void convert_VkTensorCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkTensorCreateInfoARM32 *in, VkTensorCreateInfoARM *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -26096,7 +26090,7 @@ static inline void convert_VkTensorCreateInfoARM_win32_to_host(struct conversion
     }
 }

-static inline void convert_VkTensorViewCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkTensorViewCreateInfoARM32 *in, VkTensorViewCreateInfoARM *out)
+static void convert_VkTensorViewCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkTensorViewCreateInfoARM32 *in, VkTensorViewCreateInfoARM *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -26131,7 +26125,7 @@ static inline void convert_VkTensorViewCreateInfoARM_win32_to_host(struct conver
     }
 }

-static inline void convert_VkValidationCacheCreateInfoEXT_win32_to_host(const VkValidationCacheCreateInfoEXT32 *in, VkValidationCacheCreateInfoEXT *out)
+static void convert_VkValidationCacheCreateInfoEXT_win32_to_host(const VkValidationCacheCreateInfoEXT32 *in, VkValidationCacheCreateInfoEXT *out)
 {
     if (!in) return;

@@ -26144,7 +26138,7 @@ static inline void convert_VkValidationCacheCreateInfoEXT_win32_to_host(const Vk
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionCreateInfoKHR32 *in, VkVideoSessionCreateInfoKHR *out)
+static void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionCreateInfoKHR32 *in, VkVideoSessionCreateInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -26209,7 +26203,7 @@ static inline void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conv
     }
 }

-static inline void convert_StdVideoH264SequenceParameterSetVui_win32_to_host(const StdVideoH264SequenceParameterSetVui32 *in, StdVideoH264SequenceParameterSetVui *out)
+static void convert_StdVideoH264SequenceParameterSetVui_win32_to_host(const StdVideoH264SequenceParameterSetVui32 *in, StdVideoH264SequenceParameterSetVui *out)
 {
     if (!in) return;

@@ -26231,7 +26225,7 @@ static inline void convert_StdVideoH264SequenceParameterSetVui_win32_to_host(con
     out->pHrdParameters = UlongToPtr(in->pHrdParameters);
 }

-static inline const StdVideoH264SequenceParameterSetVui *convert_StdVideoH264SequenceParameterSetVui_array_win32_to_host(struct conversion_context *ctx, const StdVideoH264SequenceParameterSetVui32 *in, uint32_t count)
+static const StdVideoH264SequenceParameterSetVui *convert_StdVideoH264SequenceParameterSetVui_array_win32_to_host(struct conversion_context *ctx, const StdVideoH264SequenceParameterSetVui32 *in, uint32_t count)
 {
     StdVideoH264SequenceParameterSetVui *out;
     unsigned int i;
@@ -26247,7 +26241,7 @@ static inline const StdVideoH264SequenceParameterSetVui *convert_StdVideoH264Seq
     return out;
 }

-static inline void convert_StdVideoH264SequenceParameterSet_win32_to_host(struct conversion_context *ctx, const StdVideoH264SequenceParameterSet32 *in, StdVideoH264SequenceParameterSet *out)
+static void convert_StdVideoH264SequenceParameterSet_win32_to_host(struct conversion_context *ctx, const StdVideoH264SequenceParameterSet32 *in, StdVideoH264SequenceParameterSet *out)
 {
     if (!in) return;

@@ -26278,7 +26272,7 @@ static inline void convert_StdVideoH264SequenceParameterSet_win32_to_host(struct
     out->pSequenceParameterSetVui = convert_StdVideoH264SequenceParameterSetVui_array_win32_to_host(ctx, (const StdVideoH264SequenceParameterSetVui32 *)UlongToPtr(in->pSequenceParameterSetVui), 1);
 }

-static inline const StdVideoH264SequenceParameterSet *convert_StdVideoH264SequenceParameterSet_array_win32_to_host(struct conversion_context *ctx, const StdVideoH264SequenceParameterSet32 *in, uint32_t count)
+static const StdVideoH264SequenceParameterSet *convert_StdVideoH264SequenceParameterSet_array_win32_to_host(struct conversion_context *ctx, const StdVideoH264SequenceParameterSet32 *in, uint32_t count)
 {
     StdVideoH264SequenceParameterSet *out;
     unsigned int i;
@@ -26294,7 +26288,7 @@ static inline const StdVideoH264SequenceParameterSet *convert_StdVideoH264Sequen
     return out;
 }

-static inline void convert_StdVideoH264PictureParameterSet_win32_to_host(const StdVideoH264PictureParameterSet32 *in, StdVideoH264PictureParameterSet *out)
+static void convert_StdVideoH264PictureParameterSet_win32_to_host(const StdVideoH264PictureParameterSet32 *in, StdVideoH264PictureParameterSet *out)
 {
     if (!in) return;

@@ -26311,7 +26305,7 @@ static inline void convert_StdVideoH264PictureParameterSet_win32_to_host(const S
     out->pScalingLists = UlongToPtr(in->pScalingLists);
 }

-static inline const StdVideoH264PictureParameterSet *convert_StdVideoH264PictureParameterSet_array_win32_to_host(struct conversion_context *ctx, const StdVideoH264PictureParameterSet32 *in, uint32_t count)
+static const StdVideoH264PictureParameterSet *convert_StdVideoH264PictureParameterSet_array_win32_to_host(struct conversion_context *ctx, const StdVideoH264PictureParameterSet32 *in, uint32_t count)
 {
     StdVideoH264PictureParameterSet *out;
     unsigned int i;
@@ -26327,7 +26321,7 @@ static inline const StdVideoH264PictureParameterSet *convert_StdVideoH264Picture
     return out;
 }

-static inline void convert_VkVideoDecodeH264SessionParametersAddInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeH264SessionParametersAddInfoKHR32 *in, VkVideoDecodeH264SessionParametersAddInfoKHR *out)
+static void convert_VkVideoDecodeH264SessionParametersAddInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeH264SessionParametersAddInfoKHR32 *in, VkVideoDecodeH264SessionParametersAddInfoKHR *out)
 {
     if (!in) return;

@@ -26341,7 +26335,7 @@ static inline void convert_VkVideoDecodeH264SessionParametersAddInfoKHR_win32_to
         FIXME("Unexpected pNext\n");
 }

-static inline const VkVideoDecodeH264SessionParametersAddInfoKHR *convert_VkVideoDecodeH264SessionParametersAddInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeH264SessionParametersAddInfoKHR32 *in, uint32_t count)
+static const VkVideoDecodeH264SessionParametersAddInfoKHR *convert_VkVideoDecodeH264SessionParametersAddInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeH264SessionParametersAddInfoKHR32 *in, uint32_t count)
 {
     VkVideoDecodeH264SessionParametersAddInfoKHR *out;
     unsigned int i;
@@ -26357,7 +26351,7 @@ static inline const VkVideoDecodeH264SessionParametersAddInfoKHR *convert_VkVide
     return out;
 }

-static inline void convert_StdVideoAV1SequenceHeader_win32_to_host(const StdVideoAV1SequenceHeader32 *in, StdVideoAV1SequenceHeader *out)
+static void convert_StdVideoAV1SequenceHeader_win32_to_host(const StdVideoAV1SequenceHeader32 *in, StdVideoAV1SequenceHeader *out)
 {
     if (!in) return;

@@ -26377,7 +26371,7 @@ static inline void convert_StdVideoAV1SequenceHeader_win32_to_host(const StdVide
     out->pTimingInfo = UlongToPtr(in->pTimingInfo);
 }

-static inline const StdVideoAV1SequenceHeader *convert_StdVideoAV1SequenceHeader_array_win32_to_host(struct conversion_context *ctx, const StdVideoAV1SequenceHeader32 *in, uint32_t count)
+static const StdVideoAV1SequenceHeader *convert_StdVideoAV1SequenceHeader_array_win32_to_host(struct conversion_context *ctx, const StdVideoAV1SequenceHeader32 *in, uint32_t count)
 {
     StdVideoAV1SequenceHeader *out;
     unsigned int i;
@@ -26393,7 +26387,7 @@ static inline const StdVideoAV1SequenceHeader *convert_StdVideoAV1SequenceHeader
     return out;
 }

-static inline void convert_VkVideoEncodeH264SessionParametersAddInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264SessionParametersAddInfoKHR32 *in, VkVideoEncodeH264SessionParametersAddInfoKHR *out)
+static void convert_VkVideoEncodeH264SessionParametersAddInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264SessionParametersAddInfoKHR32 *in, VkVideoEncodeH264SessionParametersAddInfoKHR *out)
 {
     if (!in) return;

@@ -26407,7 +26401,7 @@ static inline void convert_VkVideoEncodeH264SessionParametersAddInfoKHR_win32_to
         FIXME("Unexpected pNext\n");
 }

-static inline const VkVideoEncodeH264SessionParametersAddInfoKHR *convert_VkVideoEncodeH264SessionParametersAddInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264SessionParametersAddInfoKHR32 *in, uint32_t count)
+static const VkVideoEncodeH264SessionParametersAddInfoKHR *convert_VkVideoEncodeH264SessionParametersAddInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264SessionParametersAddInfoKHR32 *in, uint32_t count)
 {
     VkVideoEncodeH264SessionParametersAddInfoKHR *out;
     unsigned int i;
@@ -26423,7 +26417,7 @@ static inline const VkVideoEncodeH264SessionParametersAddInfoKHR *convert_VkVide
     return out;
 }

-static inline void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionParametersCreateInfoKHR32 *in, VkVideoSessionParametersCreateInfoKHR *out)
+static void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionParametersCreateInfoKHR32 *in, VkVideoSessionParametersCreateInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -26520,7 +26514,7 @@ static inline void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(s
     }
 }

-static inline void convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(const VkWin32SurfaceCreateInfoKHR32 *in, VkWin32SurfaceCreateInfoKHR *out)
+static void convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(const VkWin32SurfaceCreateInfoKHR32 *in, VkWin32SurfaceCreateInfoKHR *out)
 {
     if (!in) return;

@@ -26534,7 +26528,7 @@ static inline void convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(const VkWin
 }

#ifdef _WIN64
-static inline void convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(const VkDebugMarkerObjectNameInfoEXT *in, VkDebugMarkerObjectNameInfoEXT *out)
+static void convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(const VkDebugMarkerObjectNameInfoEXT *in, VkDebugMarkerObjectNameInfoEXT *out)
 {
     if (!in) return;

@@ -26546,7 +26540,7 @@ static inline void convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(const Vk
 }
 #endif /* _WIN64 */

-static inline void convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(const VkDebugMarkerObjectNameInfoEXT32 *in, VkDebugMarkerObjectNameInfoEXT *out)
+static void convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(const VkDebugMarkerObjectNameInfoEXT32 *in, VkDebugMarkerObjectNameInfoEXT *out)
 {
     if (!in) return;

@@ -26560,7 +26554,7 @@ static inline void convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(const Vk
 }

#ifdef _WIN64
-static inline void convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(const VkDebugMarkerObjectTagInfoEXT *in, VkDebugMarkerObjectTagInfoEXT *out)
+static void convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(const VkDebugMarkerObjectTagInfoEXT *in, VkDebugMarkerObjectTagInfoEXT *out)
 {
     if (!in) return;

@@ -26574,7 +26568,7 @@ static inline void convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(const VkD
 }
 #endif /* _WIN64 */

-static inline void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkDebugMarkerObjectTagInfoEXT32 *in, VkDebugMarkerObjectTagInfoEXT *out)
+static void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkDebugMarkerObjectTagInfoEXT32 *in, VkDebugMarkerObjectTagInfoEXT *out)
 {
     if (!in) return;

@@ -26589,19 +26583,7 @@ static inline void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkD
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPhysicalDevice_array_unwrapped_host_to_win32(const VkPhysicalDevice *in, PTR32 *out, uint32_t count)
-{
-    unsigned int i;
-
-    if (!in) return;
-
-    for (i = 0; i < count; i++)
-    {
-        out[i] = PtrToUlong(in[i]);
-    }
-}
-
-static inline void convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(const VkPhysicalDeviceGroupProperties32 *in, VkPhysicalDeviceGroupProperties *out)
+static void convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(const VkPhysicalDeviceGroupProperties32 *in, VkPhysicalDeviceGroupProperties *out)
 {
     if (!in) return;

@@ -26611,16 +26593,7 @@ static inline void convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_ho
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out)
-{
-    if (!in) return;
-
-    out->physicalDeviceCount = in->physicalDeviceCount;
-    convert_VkPhysicalDevice_array_unwrapped_host_to_win32(in->physicalDevices, out->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE);
-    out->subsetAllocation = in->subsetAllocation;
-}
-
-static inline VkPhysicalDeviceGroupProperties *convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceGroupProperties32 *in, uint32_t count)
+static VkPhysicalDeviceGroupProperties *convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceGroupProperties32 *in, uint32_t count)
 {
     VkPhysicalDeviceGroupProperties *out;
     unsigned int i;
@@ -26636,7 +26609,7 @@ static inline VkPhysicalDeviceGroupProperties *convert_VkPhysicalDeviceGroupProp
     return out;
 }

-static inline void convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out, uint32_t count)
+static void convert_VkPhysicalDevice_array_unwrapped_host_to_win32(const VkPhysicalDevice *in, PTR32 *out, uint32_t count)
 {
     unsigned int i;

@@ -26644,31 +26617,42 @@ static inline void convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_

for (i = 0; i < count; i++)
     {
-        convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(&in[i], &out[i]);
+        out[i] = PtrToUlong(in[i]);
     }
 }

-static inline void convert_VkPerformanceCounterKHR_win32_to_host(const VkPerformanceCounterKHR32 *in, VkPerformanceCounterKHR *out)
+static void convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out)
 {
     if (!in) return;

-    out->sType = in->sType;
-    out->pNext = NULL;
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
+    out->physicalDeviceCount = in->physicalDeviceCount;
+    convert_VkPhysicalDevice_array_unwrapped_host_to_win32(in->physicalDevices, out->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE);
+    out->subsetAllocation = in->subsetAllocation;
 }

-static inline void convert_VkPerformanceCounterKHR_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out)
+static void convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out, uint32_t count)
 {
+    unsigned int i;
+
     if (!in) return;

-    out->unit = in->unit;
-    out->scope = in->scope;
-    out->storage = in->storage;
-    memcpy(out->uuid, in->uuid, VK_UUID_SIZE * sizeof(uint8_t));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(&in[i], &out[i]);
+    }
+}
+
+static void convert_VkPerformanceCounterKHR_win32_to_host(const VkPerformanceCounterKHR32 *in, VkPerformanceCounterKHR *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
 }

-static inline VkPerformanceCounterKHR *convert_VkPerformanceCounterKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterKHR32 *in, uint32_t count)
+static VkPerformanceCounterKHR *convert_VkPerformanceCounterKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterKHR32 *in, uint32_t count)
 {
     VkPerformanceCounterKHR *out;
     unsigned int i;
@@ -26684,19 +26668,7 @@ static inline VkPerformanceCounterKHR *convert_VkPerformanceCounterKHR_array_win
     return out;
 }

-static inline void convert_VkPerformanceCounterKHR_array_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out, uint32_t count)
-{
-    unsigned int i;
-
-    if (!in) return;
-
-    for (i = 0; i < count; i++)
-    {
-        convert_VkPerformanceCounterKHR_host_to_win32(&in[i], &out[i]);
-    }
-}
-
-static inline void convert_VkPerformanceCounterDescriptionKHR_win32_to_host(const VkPerformanceCounterDescriptionKHR32 *in, VkPerformanceCounterDescriptionKHR *out)
+static void convert_VkPerformanceCounterDescriptionKHR_win32_to_host(const VkPerformanceCounterDescriptionKHR32 *in, VkPerformanceCounterDescriptionKHR *out)
 {
     if (!in) return;

@@ -26706,17 +26678,7 @@ static inline void convert_VkPerformanceCounterDescriptionKHR_win32_to_host(cons
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPerformanceCounterDescriptionKHR_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out)
-{
-    if (!in) return;
-
-    out->flags = in->flags;
-    memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    memcpy(out->category, in->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-}
-
-static inline VkPerformanceCounterDescriptionKHR *convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterDescriptionKHR32 *in, uint32_t count)
+static VkPerformanceCounterDescriptionKHR *convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterDescriptionKHR32 *in, uint32_t count)
 {
     VkPerformanceCounterDescriptionKHR *out;
     unsigned int i;
@@ -26732,7 +26694,17 @@ static inline VkPerformanceCounterDescriptionKHR *convert_VkPerformanceCounterDe
     return out;
 }

-static inline void convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out, uint32_t count)
+static void convert_VkPerformanceCounterKHR_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out)
+{
+    if (!in) return;
+
+    out->unit = in->unit;
+    out->scope = in->scope;
+    out->storage = in->storage;
+    memcpy(out->uuid, in->uuid, VK_UUID_SIZE * sizeof(uint8_t));
+}
+
+static void convert_VkPerformanceCounterKHR_array_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out, uint32_t count)
 {
     unsigned int i;

@@ -26740,38 +26712,47 @@ static inline void convert_VkPerformanceCounterDescriptionKHR_array_host_to_win3

for (i = 0; i < count; i++)
     {
-        convert_VkPerformanceCounterDescriptionKHR_host_to_win32(&in[i], &out[i]);
+        convert_VkPerformanceCounterKHR_host_to_win32(&in[i], &out[i]);
     }
 }

-#ifdef _WIN64
-static inline void convert_VkMappedMemoryRange_win64_to_host(const VkMappedMemoryRange *in, VkMappedMemoryRange *out)
+static void convert_VkPerformanceCounterDescriptionKHR_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out)
 {
     if (!in) return;

-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory;
-    out->offset = in->offset;
-    out->size = in->size;
+    out->flags = in->flags;
+    memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    memcpy(out->category, in->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+}
+
+static void convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out, uint32_t count)
+{
+    unsigned int i;
+
+    if (!in) return;
+
+    for (i = 0; i < count; i++)
+    {
+        convert_VkPerformanceCounterDescriptionKHR_host_to_win32(&in[i], &out[i]);
+    }
 }
-#endif /* _WIN64 */

-static inline void convert_VkMappedMemoryRange_win32_to_host(const VkMappedMemoryRange32 *in, VkMappedMemoryRange *out)
+#ifdef _WIN64
+static void convert_VkMappedMemoryRange_win64_to_host(const VkMappedMemoryRange *in, VkMappedMemoryRange *out)
 {
     if (!in) return;

out->sType = in->sType;
-    out->pNext = NULL;
+    out->pNext = in->pNext;
     out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory;
     out->offset = in->offset;
     out->size = in->size;
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
 }
+#endif /* _WIN64 */

#ifdef _WIN64
-static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win64_to_host(struct conversion_context *ctx, const VkMappedMemoryRange *in, uint32_t count)
+static const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win64_to_host(struct conversion_context *ctx, const VkMappedMemoryRange *in, uint32_t count)
 {
     VkMappedMemoryRange *out;
     unsigned int i;
@@ -26788,7 +26769,20 @@ static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win64
 }
 #endif /* _WIN64 */

-static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win32_to_host(struct conversion_context *ctx, const VkMappedMemoryRange32 *in, uint32_t count)
+static void convert_VkMappedMemoryRange_win32_to_host(const VkMappedMemoryRange32 *in, VkMappedMemoryRange *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory;
+    out->offset = in->offset;
+    out->size = in->size;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win32_to_host(struct conversion_context *ctx, const VkMappedMemoryRange32 *in, uint32_t count)
 {
     VkMappedMemoryRange *out;
     unsigned int i;
@@ -26804,7 +26798,7 @@ static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win32
     return out;
 }

-static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(const VkAccelerationStructureBuildSizesInfoKHR32 *in, VkAccelerationStructureBuildSizesInfoKHR *out)
+static void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(const VkAccelerationStructureBuildSizesInfoKHR32 *in, VkAccelerationStructureBuildSizesInfoKHR *out)
 {
     if (!in) return;

@@ -26814,7 +26808,7 @@ static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_hos
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(const VkAccelerationStructureBuildSizesInfoKHR *in, VkAccelerationStructureBuildSizesInfoKHR32 *out)
+static void convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(const VkAccelerationStructureBuildSizesInfoKHR *in, VkAccelerationStructureBuildSizesInfoKHR32 *out)
 {
     if (!in) return;

@@ -26823,7 +26817,7 @@ static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win3
     out->buildScratchSize = in->buildScratchSize;
 }

-static inline void convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host(const VkAccelerationStructureDeviceAddressInfoKHR32 *in, VkAccelerationStructureDeviceAddressInfoKHR *out)
+static void convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host(const VkAccelerationStructureDeviceAddressInfoKHR32 *in, VkAccelerationStructureDeviceAddressInfoKHR *out)
 {
     if (!in) return;

@@ -26834,7 +26828,7 @@ static inline void convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host(const VkAccelerationStructureMemoryRequirementsInfoNV32 *in, VkAccelerationStructureMemoryRequirementsInfoNV *out)
+static void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host(const VkAccelerationStructureMemoryRequirementsInfoNV32 *in, VkAccelerationStructureMemoryRequirementsInfoNV *out)
 {
     if (!in) return;

@@ -26846,33 +26840,33 @@ static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkMemoryRequirements_host_to_win32(const VkMemoryRequirements *in, VkMemoryRequirements32 *out)
+static void convert_VkMemoryRequirements2KHR_win32_to_host(const VkMemoryRequirements2KHR32 *in, VkMemoryRequirements2KHR *out)
 {
     if (!in) return;

-    out->size = in->size;
-    out->alignment = in->alignment;
-    out->memoryTypeBits = in->memoryTypeBits;
+    out->sType = in->sType;
+    out->pNext = NULL;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkMemoryRequirements2KHR_win32_to_host(const VkMemoryRequirements2KHR32 *in, VkMemoryRequirements2KHR *out)
+static void convert_VkMemoryRequirements_host_to_win32(const VkMemoryRequirements *in, VkMemoryRequirements32 *out)
 {
     if (!in) return;

-    out->sType = in->sType;
-    out->pNext = NULL;
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
+    out->size = in->size;
+    out->alignment = in->alignment;
+    out->memoryTypeBits = in->memoryTypeBits;
 }

-static inline void convert_VkMemoryRequirements2KHR_host_to_win32(const VkMemoryRequirements2KHR *in, VkMemoryRequirements2KHR32 *out)
+static void convert_VkMemoryRequirements2KHR_host_to_win32(const VkMemoryRequirements2KHR *in, VkMemoryRequirements2KHR32 *out)
 {
     if (!in) return;

convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
 }

-static inline void convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host(const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *in, VkAccelerationStructureCaptureDescriptorDataInfoEXT *out)
+static void convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host(const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *in, VkAccelerationStructureCaptureDescriptorDataInfoEXT *out)
 {
     if (!in) return;

@@ -26884,7 +26878,7 @@ static inline void convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_w
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBufferDeviceAddressInfo32 *in, VkBufferDeviceAddressInfo *out)
+static void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBufferDeviceAddressInfo32 *in, VkBufferDeviceAddressInfo *out)
 {
     if (!in) return;

@@ -26895,7 +26889,7 @@ static inline void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBuffe
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkBufferMemoryRequirementsInfo2_win32_to_host(const VkBufferMemoryRequirementsInfo232 *in, VkBufferMemoryRequirementsInfo2 *out)
+static void convert_VkBufferMemoryRequirementsInfo2_win32_to_host(const VkBufferMemoryRequirementsInfo232 *in, VkBufferMemoryRequirementsInfo2 *out)
 {
     if (!in) return;

@@ -26906,7 +26900,7 @@ static inline void convert_VkBufferMemoryRequirementsInfo2_win32_to_host(const V
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkMemoryRequirements2_win32_to_host(struct conversion_context *ctx, const VkMemoryRequirements232 *in, VkMemoryRequirements2 *out)
+static void convert_VkMemoryRequirements2_win32_to_host(struct conversion_context *ctx, const VkMemoryRequirements232 *in, VkMemoryRequirements2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -26948,7 +26942,7 @@ static inline void convert_VkMemoryRequirements2_win32_to_host(struct conversion
     }
 }

-static inline void convert_VkMemoryRequirements2_host_to_win32(const VkMemoryRequirements2 *in, VkMemoryRequirements232 *out)
+static void convert_VkMemoryRequirements2_host_to_win32(const VkMemoryRequirements2 *in, VkMemoryRequirements232 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -26987,7 +26981,7 @@ static inline void convert_VkMemoryRequirements2_host_to_win32(const VkMemoryReq
     }
 }

-static inline void convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host(const VkBufferCaptureDescriptorDataInfoEXT32 *in, VkBufferCaptureDescriptorDataInfoEXT *out)
+static void convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host(const VkBufferCaptureDescriptorDataInfoEXT32 *in, VkBufferCaptureDescriptorDataInfoEXT *out)
 {
     if (!in) return;

@@ -26998,7 +26992,7 @@ static inline void convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host(co
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCalibratedTimestampInfoKHR_win32_to_host(const VkCalibratedTimestampInfoKHR32 *in, VkCalibratedTimestampInfoKHR *out)
+static void convert_VkCalibratedTimestampInfoKHR_win32_to_host(const VkCalibratedTimestampInfoKHR32 *in, VkCalibratedTimestampInfoKHR *out)
 {
     if (!in) return;

@@ -27009,7 +27003,7 @@ static inline void convert_VkCalibratedTimestampInfoKHR_win32_to_host(const VkCa
         FIXME("Unexpected pNext\n");
 }

-static inline const VkCalibratedTimestampInfoKHR *convert_VkCalibratedTimestampInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoKHR32 *in, uint32_t count)
+static const VkCalibratedTimestampInfoKHR *convert_VkCalibratedTimestampInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoKHR32 *in, uint32_t count)
 {
     VkCalibratedTimestampInfoKHR *out;
     unsigned int i;
@@ -27025,7 +27019,7 @@ static inline const VkCalibratedTimestampInfoKHR *convert_VkCalibratedTimestampI
     return out;
 }

-static inline void convert_VkDataGraphPipelineInfoARM_win32_to_host(const VkDataGraphPipelineInfoARM32 *in, VkDataGraphPipelineInfoARM *out)
+static void convert_VkDataGraphPipelineInfoARM_win32_to_host(const VkDataGraphPipelineInfoARM32 *in, VkDataGraphPipelineInfoARM *out)
 {
     if (!in) return;

@@ -27036,7 +27030,7 @@ static inline void convert_VkDataGraphPipelineInfoARM_win32_to_host(const VkData
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDataGraphPipelinePropertyQueryResultARM_win32_to_host(const VkDataGraphPipelinePropertyQueryResultARM32 *in, VkDataGraphPipelinePropertyQueryResultARM *out)
+static void convert_VkDataGraphPipelinePropertyQueryResultARM_win32_to_host(const VkDataGraphPipelinePropertyQueryResultARM32 *in, VkDataGraphPipelinePropertyQueryResultARM *out)
 {
     if (!in) return;

@@ -27050,17 +27044,7 @@ static inline void convert_VkDataGraphPipelinePropertyQueryResultARM_win32_to_ho
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDataGraphPipelinePropertyQueryResultARM_host_to_win32(const VkDataGraphPipelinePropertyQueryResultARM *in, VkDataGraphPipelinePropertyQueryResultARM32 *out)
-{
-    if (!in) return;
-
-    out->property = in->property;
-    out->isText = in->isText;
-    out->dataSize = in->dataSize;
-    out->pData = PtrToUlong(in->pData);
-}
-
-static inline VkDataGraphPipelinePropertyQueryResultARM *convert_VkDataGraphPipelinePropertyQueryResultARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelinePropertyQueryResultARM32 *in, uint32_t count)
+static VkDataGraphPipelinePropertyQueryResultARM *convert_VkDataGraphPipelinePropertyQueryResultARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelinePropertyQueryResultARM32 *in, uint32_t count)
 {
     VkDataGraphPipelinePropertyQueryResultARM *out;
     unsigned int i;
@@ -27076,7 +27060,17 @@ static inline VkDataGraphPipelinePropertyQueryResultARM *convert_VkDataGraphPipe
     return out;
 }

-static inline void convert_VkDataGraphPipelinePropertyQueryResultARM_array_host_to_win32(const VkDataGraphPipelinePropertyQueryResultARM *in, VkDataGraphPipelinePropertyQueryResultARM32 *out, uint32_t count)
+static void convert_VkDataGraphPipelinePropertyQueryResultARM_host_to_win32(const VkDataGraphPipelinePropertyQueryResultARM *in, VkDataGraphPipelinePropertyQueryResultARM32 *out)
+{
+    if (!in) return;
+
+    out->property = in->property;
+    out->isText = in->isText;
+    out->dataSize = in->dataSize;
+    out->pData = PtrToUlong(in->pData);
+}
+
+static void convert_VkDataGraphPipelinePropertyQueryResultARM_array_host_to_win32(const VkDataGraphPipelinePropertyQueryResultARM *in, VkDataGraphPipelinePropertyQueryResultARM32 *out, uint32_t count)
 {
     unsigned int i;

@@ -27088,7 +27082,7 @@ static inline void convert_VkDataGraphPipelinePropertyQueryResultARM_array_host_
     }
 }

-static inline void convert_VkDataGraphPipelineSessionBindPointRequirementsInfoARM_win32_to_host(const VkDataGraphPipelineSessionBindPointRequirementsInfoARM32 *in, VkDataGraphPipelineSessionBindPointRequirementsInfoARM *out)
+static void convert_VkDataGraphPipelineSessionBindPointRequirementsInfoARM_win32_to_host(const VkDataGraphPipelineSessionBindPointRequirementsInfoARM32 *in, VkDataGraphPipelineSessionBindPointRequirementsInfoARM *out)
 {
     if (!in) return;

@@ -27099,7 +27093,7 @@ static inline void convert_VkDataGraphPipelineSessionBindPointRequirementsInfoAR
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDataGraphPipelineSessionBindPointRequirementARM_win32_to_host(const VkDataGraphPipelineSessionBindPointRequirementARM32 *in, VkDataGraphPipelineSessionBindPointRequirementARM *out)
+static void convert_VkDataGraphPipelineSessionBindPointRequirementARM_win32_to_host(const VkDataGraphPipelineSessionBindPointRequirementARM32 *in, VkDataGraphPipelineSessionBindPointRequirementARM *out)
 {
     if (!in) return;

@@ -27112,16 +27106,7 @@ static inline void convert_VkDataGraphPipelineSessionBindPointRequirementARM_win
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDataGraphPipelineSessionBindPointRequirementARM_host_to_win32(const VkDataGraphPipelineSessionBindPointRequirementARM *in, VkDataGraphPipelineSessionBindPointRequirementARM32 *out)
-{
-    if (!in) return;
-
-    out->bindPoint = in->bindPoint;
-    out->bindPointType = in->bindPointType;
-    out->numObjects = in->numObjects;
-}
-
-static inline VkDataGraphPipelineSessionBindPointRequirementARM *convert_VkDataGraphPipelineSessionBindPointRequirementARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineSessionBindPointRequirementARM32 *in, uint32_t count)
+static VkDataGraphPipelineSessionBindPointRequirementARM *convert_VkDataGraphPipelineSessionBindPointRequirementARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineSessionBindPointRequirementARM32 *in, uint32_t count)
 {
     VkDataGraphPipelineSessionBindPointRequirementARM *out;
     unsigned int i;
@@ -27137,7 +27122,16 @@ static inline VkDataGraphPipelineSessionBindPointRequirementARM *convert_VkDataG
     return out;
 }

-static inline void convert_VkDataGraphPipelineSessionBindPointRequirementARM_array_host_to_win32(const VkDataGraphPipelineSessionBindPointRequirementARM *in, VkDataGraphPipelineSessionBindPointRequirementARM32 *out, uint32_t count)
+static void convert_VkDataGraphPipelineSessionBindPointRequirementARM_host_to_win32(const VkDataGraphPipelineSessionBindPointRequirementARM *in, VkDataGraphPipelineSessionBindPointRequirementARM32 *out)
+{
+    if (!in) return;
+
+    out->bindPoint = in->bindPoint;
+    out->bindPointType = in->bindPointType;
+    out->numObjects = in->numObjects;
+}
+
+static void convert_VkDataGraphPipelineSessionBindPointRequirementARM_array_host_to_win32(const VkDataGraphPipelineSessionBindPointRequirementARM *in, VkDataGraphPipelineSessionBindPointRequirementARM32 *out, uint32_t count)
 {
     unsigned int i;

@@ -27149,7 +27143,7 @@ static inline void convert_VkDataGraphPipelineSessionBindPointRequirementARM_arr
     }
 }

-static inline void convert_VkDataGraphPipelineSessionMemoryRequirementsInfoARM_win32_to_host(const VkDataGraphPipelineSessionMemoryRequirementsInfoARM32 *in, VkDataGraphPipelineSessionMemoryRequirementsInfoARM *out)
+static void convert_VkDataGraphPipelineSessionMemoryRequirementsInfoARM_win32_to_host(const VkDataGraphPipelineSessionMemoryRequirementsInfoARM32 *in, VkDataGraphPipelineSessionMemoryRequirementsInfoARM *out)
 {
     if (!in) return;

@@ -27162,7 +27156,7 @@ static inline void convert_VkDataGraphPipelineSessionMemoryRequirementsInfoARM_w
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDescriptorAddressInfoEXT_win32_to_host(const VkDescriptorAddressInfoEXT32 *in, VkDescriptorAddressInfoEXT *out)
+static void convert_VkDescriptorAddressInfoEXT_win32_to_host(const VkDescriptorAddressInfoEXT32 *in, VkDescriptorAddressInfoEXT *out)
 {
     if (!in) return;

@@ -27175,7 +27169,7 @@ static inline void convert_VkDescriptorAddressInfoEXT_win32_to_host(const VkDesc
         FIXME("Unexpected pNext\n");
 }

-static inline const VkDescriptorAddressInfoEXT *convert_VkDescriptorAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorAddressInfoEXT32 *in, uint32_t count)
+static const VkDescriptorAddressInfoEXT *convert_VkDescriptorAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorAddressInfoEXT32 *in, uint32_t count)
 {
     VkDescriptorAddressInfoEXT *out;
     unsigned int i;
@@ -27191,7 +27185,7 @@ static inline const VkDescriptorAddressInfoEXT *convert_VkDescriptorAddressInfoE
     return out;
 }

-static inline void convert_VkDescriptorDataEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorDataEXT32 *in, VkDescriptorDataEXT *out, VkFlags selector)
+static void convert_VkDescriptorDataEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorDataEXT32 *in, VkDescriptorDataEXT *out, VkFlags selector)
 {
     if (!in) return;

@@ -27217,7 +27211,7 @@ static inline void convert_VkDescriptorDataEXT_win32_to_host(struct conversion_c
         out->accelerationStructure = in->accelerationStructure;
 }

-static inline void convert_VkDescriptorGetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorGetInfoEXT32 *in, VkDescriptorGetInfoEXT *out)
+static void convert_VkDescriptorGetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorGetInfoEXT32 *in, VkDescriptorGetInfoEXT *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -27251,7 +27245,7 @@ static inline void convert_VkDescriptorGetInfoEXT_win32_to_host(struct conversio
     }
 }

-static inline void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(const VkDescriptorSetBindingReferenceVALVE32 *in, VkDescriptorSetBindingReferenceVALVE *out)
+static void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(const VkDescriptorSetBindingReferenceVALVE32 *in, VkDescriptorSetBindingReferenceVALVE *out)
 {
     if (!in) return;

@@ -27263,7 +27257,7 @@ static inline void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(co
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host(const VkDescriptorSetLayoutHostMappingInfoVALVE32 *in, VkDescriptorSetLayoutHostMappingInfoVALVE *out)
+static void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host(const VkDescriptorSetLayoutHostMappingInfoVALVE32 *in, VkDescriptorSetLayoutHostMappingInfoVALVE *out)
 {
     if (!in) return;

@@ -27275,7 +27269,7 @@ static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_ho
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(const VkDescriptorSetLayoutHostMappingInfoVALVE *in, VkDescriptorSetLayoutHostMappingInfoVALVE32 *out)
+static void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(const VkDescriptorSetLayoutHostMappingInfoVALVE *in, VkDescriptorSetLayoutHostMappingInfoVALVE32 *out)
 {
     if (!in) return;

@@ -27283,7 +27277,7 @@ static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win
     out->descriptorSize = in->descriptorSize;
 }

-static inline void convert_VkDescriptorSetLayoutSupport_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutSupport32 *in, VkDescriptorSetLayoutSupport *out)
+static void convert_VkDescriptorSetLayoutSupport_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutSupport32 *in, VkDescriptorSetLayoutSupport *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -27313,7 +27307,7 @@ static inline void convert_VkDescriptorSetLayoutSupport_win32_to_host(struct con
     }
 }

-static inline void convert_VkDescriptorSetLayoutSupport_host_to_win32(const VkDescriptorSetLayoutSupport *in, VkDescriptorSetLayoutSupport32 *out)
+static void convert_VkDescriptorSetLayoutSupport_host_to_win32(const VkDescriptorSetLayoutSupport *in, VkDescriptorSetLayoutSupport32 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -27341,7 +27335,7 @@ static inline void convert_VkDescriptorSetLayoutSupport_host_to_win32(const VkDe
     }
 }

-static inline void convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(const VkAccelerationStructureVersionInfoKHR32 *in, VkAccelerationStructureVersionInfoKHR *out)
+static void convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(const VkAccelerationStructureVersionInfoKHR32 *in, VkAccelerationStructureVersionInfoKHR *out)
 {
     if (!in) return;

@@ -27352,7 +27346,7 @@ static inline void convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(c
         FIXME("Unexpected pNext\n");
 }

-static inline const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, uint32_t count)
+static const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, uint32_t count)
 {
     VkBufferCreateInfo *out;
     unsigned int i;
@@ -27368,7 +27362,7 @@ static inline const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win32_t
     return out;
 }

-static inline void convert_VkDeviceBufferMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceBufferMemoryRequirements32 *in, VkDeviceBufferMemoryRequirements *out)
+static void convert_VkDeviceBufferMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceBufferMemoryRequirements32 *in, VkDeviceBufferMemoryRequirements *out)
 {
     if (!in) return;

@@ -27379,7 +27373,7 @@ static inline void convert_VkDeviceBufferMemoryRequirements_win32_to_host(struct
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFaultCountsEXT32 *in, VkDeviceFaultCountsEXT *out)
+static void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFaultCountsEXT32 *in, VkDeviceFaultCountsEXT *out)
 {
     if (!in) return;

@@ -27392,36 +27386,43 @@ static inline void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFa
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDeviceFaultCountsEXT_host_to_win32(const VkDeviceFaultCountsEXT *in, VkDeviceFaultCountsEXT32 *out)
+static void convert_VkDeviceFaultAddressInfoEXT_win32_to_host(const VkDeviceFaultAddressInfoEXT32 *in, VkDeviceFaultAddressInfoEXT *out)
 {
     if (!in) return;

-    out->addressInfoCount = in->addressInfoCount;
-    out->vendorInfoCount = in->vendorInfoCount;
-    out->vendorBinarySize = in->vendorBinarySize;
+    out->addressType = in->addressType;
+    out->reportedAddress = in->reportedAddress;
+    out->addressPrecision = in->addressPrecision;
 }

-static inline void convert_VkDeviceFaultAddressInfoEXT_win32_to_host(const VkDeviceFaultAddressInfoEXT32 *in, VkDeviceFaultAddressInfoEXT *out)
+static VkDeviceFaultAddressInfoEXT *convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultAddressInfoEXT32 *in, uint32_t count)
 {
-    if (!in) return;
+    VkDeviceFaultAddressInfoEXT *out;
+    unsigned int i;

-    out->addressType = in->addressType;
-    out->reportedAddress = in->reportedAddress;
-    out->addressPrecision = in->addressPrecision;
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkDeviceFaultAddressInfoEXT_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
 }

-static inline void convert_VkDeviceFaultAddressInfoEXT_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out)
+static void convert_VkDeviceFaultVendorInfoEXT_win32_to_host(const VkDeviceFaultVendorInfoEXT32 *in, VkDeviceFaultVendorInfoEXT *out)
 {
     if (!in) return;

-    out->addressType = in->addressType;
-    out->reportedAddress = in->reportedAddress;
-    out->addressPrecision = in->addressPrecision;
+    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    out->vendorFaultCode = in->vendorFaultCode;
+    out->vendorFaultData = in->vendorFaultData;
 }

-static inline VkDeviceFaultAddressInfoEXT *convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultAddressInfoEXT32 *in, uint32_t count)
+static VkDeviceFaultVendorInfoEXT *convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultVendorInfoEXT32 *in, uint32_t count)
 {
-    VkDeviceFaultAddressInfoEXT *out;
+    VkDeviceFaultVendorInfoEXT *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -27429,13 +27430,43 @@ static inline VkDeviceFaultAddressInfoEXT *convert_VkDeviceFaultAddressInfoEXT_a
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkDeviceFaultAddressInfoEXT_win32_to_host(&in[i], &out[i]);
+        convert_VkDeviceFaultVendorInfoEXT_win32_to_host(&in[i], &out[i]);
     }

return out;
 }

-static inline void convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out, uint32_t count)
+static void convert_VkDeviceFaultInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultInfoEXT32 *in, VkDeviceFaultInfoEXT *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(in->pAddressInfos), 1);
+    out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(in->pVendorInfos), 1);
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static void convert_VkDeviceFaultCountsEXT_host_to_win32(const VkDeviceFaultCountsEXT *in, VkDeviceFaultCountsEXT32 *out)
+{
+    if (!in) return;
+
+    out->addressInfoCount = in->addressInfoCount;
+    out->vendorInfoCount = in->vendorInfoCount;
+    out->vendorBinarySize = in->vendorBinarySize;
+}
+
+static void convert_VkDeviceFaultAddressInfoEXT_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out)
+{
+    if (!in) return;
+
+    out->addressType = in->addressType;
+    out->reportedAddress = in->reportedAddress;
+    out->addressPrecision = in->addressPrecision;
+}
+
+static void convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out, uint32_t count)
 {
     unsigned int i;

@@ -27447,16 +27478,7 @@ static inline void convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(const
     }
 }

-static inline void convert_VkDeviceFaultVendorInfoEXT_win32_to_host(const VkDeviceFaultVendorInfoEXT32 *in, VkDeviceFaultVendorInfoEXT *out)
-{
-    if (!in) return;
-
-    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    out->vendorFaultCode = in->vendorFaultCode;
-    out->vendorFaultData = in->vendorFaultData;
-}
-
-static inline void convert_VkDeviceFaultVendorInfoEXT_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out)
+static void convert_VkDeviceFaultVendorInfoEXT_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out)
 {
     if (!in) return;

@@ -27465,23 +27487,7 @@ static inline void convert_VkDeviceFaultVendorInfoEXT_host_to_win32(const VkDevi
     out->vendorFaultData = in->vendorFaultData;
 }

-static inline VkDeviceFaultVendorInfoEXT *convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultVendorInfoEXT32 *in, uint32_t count)
-{
-    VkDeviceFaultVendorInfoEXT *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkDeviceFaultVendorInfoEXT_win32_to_host(&in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out, uint32_t count)
+static void convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out, uint32_t count)
 {
     unsigned int i;

@@ -27493,19 +27499,7 @@ static inline void convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(const
     }
 }

-static inline void convert_VkDeviceFaultInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultInfoEXT32 *in, VkDeviceFaultInfoEXT *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(in->pAddressInfos), 1);
-    out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(in->pVendorInfos), 1);
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
-}
-
-static inline void convert_VkDeviceFaultInfoEXT_host_to_win32(const VkDeviceFaultInfoEXT *in, VkDeviceFaultInfoEXT32 *out)
+static void convert_VkDeviceFaultInfoEXT_host_to_win32(const VkDeviceFaultInfoEXT *in, VkDeviceFaultInfoEXT32 *out)
 {
     if (!in) return;

@@ -27515,7 +27509,7 @@ static inline void convert_VkDeviceFaultInfoEXT_host_to_win32(const VkDeviceFaul
     out->pVendorBinaryData = PtrToUlong(in->pVendorBinaryData);
 }

-static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(const VkDeviceGroupPresentCapabilitiesKHR32 *in, VkDeviceGroupPresentCapabilitiesKHR *out)
+static void convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(const VkDeviceGroupPresentCapabilitiesKHR32 *in, VkDeviceGroupPresentCapabilitiesKHR *out)
 {
     if (!in) return;

@@ -27525,7 +27519,7 @@ static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(con
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(const VkDeviceGroupPresentCapabilitiesKHR *in, VkDeviceGroupPresentCapabilitiesKHR32 *out)
+static void convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(const VkDeviceGroupPresentCapabilitiesKHR *in, VkDeviceGroupPresentCapabilitiesKHR32 *out)
 {
     if (!in) return;

@@ -27534,7 +27528,7 @@ static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(con
 }

#ifdef _WIN64
-static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkImageCreateInfo *in, uint32_t count)
+static const VkImageCreateInfo *convert_VkImageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkImageCreateInfo *in, uint32_t count)
 {
     VkImageCreateInfo *out;
     unsigned int i;
@@ -27551,7 +27545,19 @@ static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win64_to_
 }
 #endif /* _WIN64 */

-static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, uint32_t count)
+#ifdef _WIN64
+static void convert_VkDeviceImageMemoryRequirements_win64_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements *in, VkDeviceImageMemoryRequirements *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->pCreateInfo = convert_VkImageCreateInfo_array_win64_to_host(ctx, in->pCreateInfo, 1);
+    out->planeAspect = in->planeAspect;
+}
+#endif /* _WIN64 */
+
+static const VkImageCreateInfo *convert_VkImageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, uint32_t count)
 {
     VkImageCreateInfo *out;
     unsigned int i;
@@ -27567,19 +27573,7 @@ static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win32_to_
     return out;
 }

-#ifdef _WIN64
-static inline void convert_VkDeviceImageMemoryRequirements_win64_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements *in, VkDeviceImageMemoryRequirements *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->pCreateInfo = convert_VkImageCreateInfo_array_win64_to_host(ctx, in->pCreateInfo, 1);
-    out->planeAspect = in->planeAspect;
-}
-#endif /* _WIN64 */
-
-static inline void convert_VkDeviceImageMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements32 *in, VkDeviceImageMemoryRequirements *out)
+static void convert_VkDeviceImageMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements32 *in, VkDeviceImageMemoryRequirements *out)
 {
     if (!in) return;

@@ -27591,18 +27585,7 @@ static inline void convert_VkDeviceImageMemoryRequirements_win32_to_host(struct
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkSparseImageMemoryRequirements_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out)
-{
-    if (!in) return;
-
-    out->formatProperties = in->formatProperties;
-    out->imageMipTailFirstLod = in->imageMipTailFirstLod;
-    out->imageMipTailSize = in->imageMipTailSize;
-    out->imageMipTailOffset = in->imageMipTailOffset;
-    out->imageMipTailStride = in->imageMipTailStride;
-}
-
-static inline void convert_VkSparseImageMemoryRequirements2_win32_to_host(const VkSparseImageMemoryRequirements232 *in, VkSparseImageMemoryRequirements2 *out)
+static void convert_VkSparseImageMemoryRequirements2_win32_to_host(const VkSparseImageMemoryRequirements232 *in, VkSparseImageMemoryRequirements2 *out)
 {
     if (!in) return;

@@ -27612,14 +27595,7 @@ static inline void convert_VkSparseImageMemoryRequirements2_win32_to_host(const
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkSparseImageMemoryRequirements2_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out)
-{
-    if (!in) return;
-
-    convert_VkSparseImageMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
-}
-
-static inline VkSparseImageMemoryRequirements2 *convert_VkSparseImageMemoryRequirements2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryRequirements232 *in, uint32_t count)
+static VkSparseImageMemoryRequirements2 *convert_VkSparseImageMemoryRequirements2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryRequirements232 *in, uint32_t count)
 {
     VkSparseImageMemoryRequirements2 *out;
     unsigned int i;
@@ -27635,47 +27611,38 @@ static inline VkSparseImageMemoryRequirements2 *convert_VkSparseImageMemoryRequi
     return out;
 }

-static inline void convert_VkSparseImageMemoryRequirements2_array_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out, uint32_t count)
+static void convert_VkSparseImageMemoryRequirements_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out)
 {
-    unsigned int i;
-
     if (!in) return;

-    for (i = 0; i < count; i++)
-    {
-        convert_VkSparseImageMemoryRequirements2_host_to_win32(&in[i], &out[i]);
-    }
+    out->formatProperties = in->formatProperties;
+    out->imageMipTailFirstLod = in->imageMipTailFirstLod;
+    out->imageMipTailSize = in->imageMipTailSize;
+    out->imageMipTailOffset = in->imageMipTailOffset;
+    out->imageMipTailStride = in->imageMipTailStride;
 }

-static inline void convert_VkImageSubresource2_win32_to_host(const VkImageSubresource232 *in, VkImageSubresource2 *out)
+static void convert_VkSparseImageMemoryRequirements2_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out)
 {
     if (!in) return;

-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->imageSubresource = in->imageSubresource;
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
+    convert_VkSparseImageMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
 }

-static inline const VkImageSubresource2 *convert_VkImageSubresource2_array_win32_to_host(struct conversion_context *ctx, const VkImageSubresource232 *in, uint32_t count)
+static void convert_VkSparseImageMemoryRequirements2_array_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out, uint32_t count)
 {
-    VkImageSubresource2 *out;
     unsigned int i;

-    if (!in || !count) return NULL;
+    if (!in) return;

-    out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkImageSubresource2_win32_to_host(&in[i], &out[i]);
+        convert_VkSparseImageMemoryRequirements2_host_to_win32(&in[i], &out[i]);
     }
-
-    return out;
 }

#ifdef _WIN64
-static inline void convert_VkDeviceImageSubresourceInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceImageSubresourceInfo *in, VkDeviceImageSubresourceInfo *out)
+static void convert_VkDeviceImageSubresourceInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceImageSubresourceInfo *in, VkDeviceImageSubresourceInfo *out)
 {
     if (!in) return;

@@ -27686,41 +27653,46 @@ static inline void convert_VkDeviceImageSubresourceInfo_win64_to_host(struct con
 }
 #endif /* _WIN64 */

-static inline void convert_VkDeviceImageSubresourceInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceImageSubresourceInfo32 *in, VkDeviceImageSubresourceInfo *out)
+static void convert_VkImageSubresource2_win32_to_host(const VkImageSubresource232 *in, VkImageSubresource2 *out)
 {
     if (!in) return;

out->sType = in->sType;
     out->pNext = NULL;
-    out->pCreateInfo = convert_VkImageCreateInfo_array_win32_to_host(ctx, (const VkImageCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1);
-    out->pSubresource = convert_VkImageSubresource2_array_win32_to_host(ctx, (const VkImageSubresource232 *)UlongToPtr(in->pSubresource), 1);
+    out->imageSubresource = in->imageSubresource;
     if (in->pNext)
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkSubresourceLayout_win32_to_host(const VkSubresourceLayout32 *in, VkSubresourceLayout *out)
+static const VkImageSubresource2 *convert_VkImageSubresource2_array_win32_to_host(struct conversion_context *ctx, const VkImageSubresource232 *in, uint32_t count)
 {
-    if (!in) return;
+    VkImageSubresource2 *out;
+    unsigned int i;

-    out->offset = in->offset;
-    out->size = in->size;
-    out->rowPitch = in->rowPitch;
-    out->arrayPitch = in->arrayPitch;
-    out->depthPitch = in->depthPitch;
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkImageSubresource2_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
 }

-static inline void convert_VkSubresourceLayout_host_to_win32(const VkSubresourceLayout *in, VkSubresourceLayout32 *out)
+static void convert_VkDeviceImageSubresourceInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceImageSubresourceInfo32 *in, VkDeviceImageSubresourceInfo *out)
 {
     if (!in) return;

-    out->offset = in->offset;
-    out->size = in->size;
-    out->rowPitch = in->rowPitch;
-    out->arrayPitch = in->arrayPitch;
-    out->depthPitch = in->depthPitch;
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->pCreateInfo = convert_VkImageCreateInfo_array_win32_to_host(ctx, (const VkImageCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1);
+    out->pSubresource = convert_VkImageSubresource2_array_win32_to_host(ctx, (const VkImageSubresource232 *)UlongToPtr(in->pSubresource), 1);
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkSubresourceLayout2_win32_to_host(struct conversion_context *ctx, const VkSubresourceLayout232 *in, VkSubresourceLayout2 *out)
+static void convert_VkSubresourceLayout2_win32_to_host(struct conversion_context *ctx, const VkSubresourceLayout232 *in, VkSubresourceLayout2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -27759,7 +27731,18 @@ static inline void convert_VkSubresourceLayout2_win32_to_host(struct conversion_
     }
 }

-static inline void convert_VkSubresourceLayout2_host_to_win32(const VkSubresourceLayout2 *in, VkSubresourceLayout232 *out)
+static void convert_VkSubresourceLayout_host_to_win32(const VkSubresourceLayout *in, VkSubresourceLayout32 *out)
+{
+    if (!in) return;
+
+    out->offset = in->offset;
+    out->size = in->size;
+    out->rowPitch = in->rowPitch;
+    out->arrayPitch = in->arrayPitch;
+    out->depthPitch = in->depthPitch;
+}
+
+static void convert_VkSubresourceLayout2_host_to_win32(const VkSubresourceLayout2 *in, VkSubresourceLayout232 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -27798,7 +27781,7 @@ static inline void convert_VkSubresourceLayout2_host_to_win32(const VkSubresourc
 }

#ifdef _WIN64
-static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out)
+static void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out)
 {
     if (!in) return;

@@ -27808,7 +27791,7 @@ static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(
 }
 #endif /* _WIN64 */

-static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo32 *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out)
+static void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo32 *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out)
 {
     if (!in) return;

@@ -27819,7 +27802,7 @@ static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkMicromapVersionInfoEXT_win32_to_host(const VkMicromapVersionInfoEXT32 *in, VkMicromapVersionInfoEXT *out)
+static void convert_VkMicromapVersionInfoEXT_win32_to_host(const VkMicromapVersionInfoEXT32 *in, VkMicromapVersionInfoEXT *out)
 {
     if (!in) return;

@@ -27830,7 +27813,7 @@ static inline void convert_VkMicromapVersionInfoEXT_win32_to_host(const VkMicrom
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkDeviceQueueInfo2_win32_to_host(const VkDeviceQueueInfo232 *in, VkDeviceQueueInfo2 *out)
+static void convert_VkDeviceQueueInfo2_win32_to_host(const VkDeviceQueueInfo232 *in, VkDeviceQueueInfo2 *out)
 {
     if (!in) return;

@@ -27843,7 +27826,7 @@ static inline void convert_VkDeviceQueueInfo2_win32_to_host(const VkDeviceQueueI
         FIXME("Unexpected pNext\n");
 }

-static inline const VkTensorCreateInfoARM *convert_VkTensorCreateInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorCreateInfoARM32 *in, uint32_t count)
+static const VkTensorCreateInfoARM *convert_VkTensorCreateInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorCreateInfoARM32 *in, uint32_t count)
 {
     VkTensorCreateInfoARM *out;
     unsigned int i;
@@ -27859,7 +27842,7 @@ static inline const VkTensorCreateInfoARM *convert_VkTensorCreateInfoARM_array_w
     return out;
 }

-static inline void convert_VkDeviceTensorMemoryRequirementsARM_win32_to_host(struct conversion_context *ctx, const VkDeviceTensorMemoryRequirementsARM32 *in, VkDeviceTensorMemoryRequirementsARM *out)
+static void convert_VkDeviceTensorMemoryRequirementsARM_win32_to_host(struct conversion_context *ctx, const VkDeviceTensorMemoryRequirementsARM32 *in, VkDeviceTensorMemoryRequirementsARM *out)
 {
     if (!in) return;

@@ -27870,7 +27853,7 @@ static inline void convert_VkDeviceTensorMemoryRequirementsARM_win32_to_host(str
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkTilePropertiesQCOM_win32_to_host(const VkTilePropertiesQCOM32 *in, VkTilePropertiesQCOM *out)
+static void convert_VkTilePropertiesQCOM_win32_to_host(const VkTilePropertiesQCOM32 *in, VkTilePropertiesQCOM *out)
 {
     if (!in) return;

@@ -27883,7 +27866,7 @@ static inline void convert_VkTilePropertiesQCOM_win32_to_host(const VkTileProper
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkTilePropertiesQCOM_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out)
+static void convert_VkTilePropertiesQCOM_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out)
 {
     if (!in) return;

@@ -27892,7 +27875,7 @@ static inline void convert_VkTilePropertiesQCOM_host_to_win32(const VkTileProper
     out->origin = in->origin;
 }

-static inline void convert_VkVideoEncodeSessionParametersGetInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeSessionParametersGetInfoKHR32 *in, VkVideoEncodeSessionParametersGetInfoKHR *out)
+static void convert_VkVideoEncodeSessionParametersGetInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeSessionParametersGetInfoKHR32 *in, VkVideoEncodeSessionParametersGetInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -27928,7 +27911,7 @@ static inline void convert_VkVideoEncodeSessionParametersGetInfoKHR_win32_to_hos
     }
 }

-static inline void convert_VkVideoEncodeSessionParametersFeedbackInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeSessionParametersFeedbackInfoKHR32 *in, VkVideoEncodeSessionParametersFeedbackInfoKHR *out)
+static void convert_VkVideoEncodeSessionParametersFeedbackInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeSessionParametersFeedbackInfoKHR32 *in, VkVideoEncodeSessionParametersFeedbackInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -27958,7 +27941,7 @@ static inline void convert_VkVideoEncodeSessionParametersFeedbackInfoKHR_win32_t
     }
 }

-static inline void convert_VkVideoEncodeSessionParametersFeedbackInfoKHR_host_to_win32(const VkVideoEncodeSessionParametersFeedbackInfoKHR *in, VkVideoEncodeSessionParametersFeedbackInfoKHR32 *out)
+static void convert_VkVideoEncodeSessionParametersFeedbackInfoKHR_host_to_win32(const VkVideoEncodeSessionParametersFeedbackInfoKHR *in, VkVideoEncodeSessionParametersFeedbackInfoKHR32 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -27987,7 +27970,7 @@ static inline void convert_VkVideoEncodeSessionParametersFeedbackInfoKHR_host_to
     }
 }

-static inline VkTilePropertiesQCOM *convert_VkTilePropertiesQCOM_array_win32_to_host(struct conversion_context *ctx, const VkTilePropertiesQCOM32 *in, uint32_t count)
+static VkTilePropertiesQCOM *convert_VkTilePropertiesQCOM_array_win32_to_host(struct conversion_context *ctx, const VkTilePropertiesQCOM32 *in, uint32_t count)
 {
     VkTilePropertiesQCOM *out;
     unsigned int i;
@@ -28003,7 +27986,7 @@ static inline VkTilePropertiesQCOM *convert_VkTilePropertiesQCOM_array_win32_to_
     return out;
 }

-static inline void convert_VkTilePropertiesQCOM_array_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out, uint32_t count)
+static void convert_VkTilePropertiesQCOM_array_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out, uint32_t count)
 {
     unsigned int i;

@@ -28015,7 +27998,7 @@ static inline void convert_VkTilePropertiesQCOM_array_host_to_win32(const VkTile
     }
 }

-static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *in, VkGeneratedCommandsMemoryRequirementsInfoEXT *out)
+static void convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *in, VkGeneratedCommandsMemoryRequirementsInfoEXT *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -28063,7 +28046,7 @@ static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_win32_to
     }
 }

-static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV32 *in, VkGeneratedCommandsMemoryRequirementsInfoNV *out)
+static void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV32 *in, VkGeneratedCommandsMemoryRequirementsInfoNV *out)
 {
     if (!in) return;

@@ -28077,7 +28060,7 @@ static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkImageMemoryRequirementsInfo2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryRequirementsInfo232 *in, VkImageMemoryRequirementsInfo2 *out)
+static void convert_VkImageMemoryRequirementsInfo2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryRequirementsInfo232 *in, VkImageMemoryRequirementsInfo2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -28110,7 +28093,7 @@ static inline void convert_VkImageMemoryRequirementsInfo2_win32_to_host(struct c
     }
 }

-static inline void convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageCaptureDescriptorDataInfoEXT32 *in, VkImageCaptureDescriptorDataInfoEXT *out)
+static void convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageCaptureDescriptorDataInfoEXT32 *in, VkImageCaptureDescriptorDataInfoEXT *out)
 {
     if (!in) return;

@@ -28121,7 +28104,7 @@ static inline void convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host(con
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkSparseImageMemoryRequirements_array_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out, uint32_t count)
+static void convert_VkSparseImageMemoryRequirements_array_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out, uint32_t count)
 {
     unsigned int i;

@@ -28133,7 +28116,7 @@ static inline void convert_VkSparseImageMemoryRequirements_array_host_to_win32(c
     }
 }

-static inline void convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(const VkImageSparseMemoryRequirementsInfo232 *in, VkImageSparseMemoryRequirementsInfo2 *out)
+static void convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(const VkImageSparseMemoryRequirementsInfo232 *in, VkImageSparseMemoryRequirementsInfo2 *out)
 {
     if (!in) return;

@@ -28144,7 +28127,18 @@ static inline void convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(co
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkImageViewAddressPropertiesNVX_win32_to_host(const VkImageViewAddressPropertiesNVX32 *in, VkImageViewAddressPropertiesNVX *out)
+static void convert_VkSubresourceLayout_win32_to_host(const VkSubresourceLayout32 *in, VkSubresourceLayout *out)
+{
+    if (!in) return;
+
+    out->offset = in->offset;
+    out->size = in->size;
+    out->rowPitch = in->rowPitch;
+    out->arrayPitch = in->arrayPitch;
+    out->depthPitch = in->depthPitch;
+}
+
+static void convert_VkImageViewAddressPropertiesNVX_win32_to_host(const VkImageViewAddressPropertiesNVX32 *in, VkImageViewAddressPropertiesNVX *out)
 {
     if (!in) return;

@@ -28154,7 +28148,7 @@ static inline void convert_VkImageViewAddressPropertiesNVX_win32_to_host(const V
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkImageViewAddressPropertiesNVX_host_to_win32(const VkImageViewAddressPropertiesNVX *in, VkImageViewAddressPropertiesNVX32 *out)
+static void convert_VkImageViewAddressPropertiesNVX_host_to_win32(const VkImageViewAddressPropertiesNVX *in, VkImageViewAddressPropertiesNVX32 *out)
 {
     if (!in) return;

@@ -28162,7 +28156,7 @@ static inline void convert_VkImageViewAddressPropertiesNVX_host_to_win32(const V
     out->size = in->size;
 }

-static inline void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageViewHandleInfoNVX32 *in, VkImageViewHandleInfoNVX *out)
+static void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageViewHandleInfoNVX32 *in, VkImageViewHandleInfoNVX *out)
 {
     if (!in) return;

@@ -28175,7 +28169,7 @@ static inline void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageV
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageViewCaptureDescriptorDataInfoEXT32 *in, VkImageViewCaptureDescriptorDataInfoEXT *out)
+static void convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageViewCaptureDescriptorDataInfoEXT32 *in, VkImageViewCaptureDescriptorDataInfoEXT *out)
 {
     if (!in) return;

@@ -28186,17 +28180,45 @@ static inline void convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkLatencyTimingsFrameReportNV_win32_to_host(const VkLatencyTimingsFrameReportNV32 *in, VkLatencyTimingsFrameReportNV *out)
+static void convert_VkLatencyTimingsFrameReportNV_win32_to_host(const VkLatencyTimingsFrameReportNV32 *in, VkLatencyTimingsFrameReportNV *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static VkLatencyTimingsFrameReportNV *convert_VkLatencyTimingsFrameReportNV_array_win32_to_host(struct conversion_context *ctx, const VkLatencyTimingsFrameReportNV32 *in, uint32_t count)
+{
+    VkLatencyTimingsFrameReportNV *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkLatencyTimingsFrameReportNV_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkGetLatencyMarkerInfoNV_win32_to_host(struct conversion_context *ctx, const VkGetLatencyMarkerInfoNV32 *in, VkGetLatencyMarkerInfoNV *out)
 {
     if (!in) return;

out->sType = in->sType;
     out->pNext = NULL;
+    out->timingCount = in->timingCount;
+    out->pTimings = convert_VkLatencyTimingsFrameReportNV_array_win32_to_host(ctx, (VkLatencyTimingsFrameReportNV32 *)UlongToPtr(in->pTimings), in->timingCount);
     if (in->pNext)
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkLatencyTimingsFrameReportNV_host_to_win32(const VkLatencyTimingsFrameReportNV *in, VkLatencyTimingsFrameReportNV32 *out)
+static void convert_VkLatencyTimingsFrameReportNV_host_to_win32(const VkLatencyTimingsFrameReportNV *in, VkLatencyTimingsFrameReportNV32 *out)
 {
     if (!in) return;

@@ -28216,23 +28238,7 @@ static inline void convert_VkLatencyTimingsFrameReportNV_host_to_win32(const VkL
     out->gpuRenderEndTimeUs = in->gpuRenderEndTimeUs;
 }

-static inline VkLatencyTimingsFrameReportNV *convert_VkLatencyTimingsFrameReportNV_array_win32_to_host(struct conversion_context *ctx, const VkLatencyTimingsFrameReportNV32 *in, uint32_t count)
-{
-    VkLatencyTimingsFrameReportNV *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkLatencyTimingsFrameReportNV_win32_to_host(&in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkLatencyTimingsFrameReportNV_array_host_to_win32(const VkLatencyTimingsFrameReportNV *in, VkLatencyTimingsFrameReportNV32 *out, uint32_t count)
+static void convert_VkLatencyTimingsFrameReportNV_array_host_to_win32(const VkLatencyTimingsFrameReportNV *in, VkLatencyTimingsFrameReportNV32 *out, uint32_t count)
 {
     unsigned int i;

@@ -28244,19 +28250,7 @@ static inline void convert_VkLatencyTimingsFrameReportNV_array_host_to_win32(con
     }
 }

-static inline void convert_VkGetLatencyMarkerInfoNV_win32_to_host(struct conversion_context *ctx, const VkGetLatencyMarkerInfoNV32 *in, VkGetLatencyMarkerInfoNV *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-    out->timingCount = in->timingCount;
-    out->pTimings = convert_VkLatencyTimingsFrameReportNV_array_win32_to_host(ctx, (VkLatencyTimingsFrameReportNV32 *)UlongToPtr(in->pTimings), in->timingCount);
-    if (in->pNext)
-        FIXME("Unexpected pNext\n");
-}
-
-static inline void convert_VkGetLatencyMarkerInfoNV_host_to_win32(const VkGetLatencyMarkerInfoNV *in, VkGetLatencyMarkerInfoNV32 *out)
+static void convert_VkGetLatencyMarkerInfoNV_host_to_win32(const VkGetLatencyMarkerInfoNV *in, VkGetLatencyMarkerInfoNV32 *out)
 {
     if (!in) return;

@@ -28264,7 +28258,7 @@ static inline void convert_VkGetLatencyMarkerInfoNV_host_to_win32(const VkGetLat
     convert_VkLatencyTimingsFrameReportNV_array_host_to_win32(in->pTimings, (VkLatencyTimingsFrameReportNV32 *)UlongToPtr(out->pTimings), in->timingCount);
 }

-static inline void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const VkMemoryHostPointerPropertiesEXT32 *in, VkMemoryHostPointerPropertiesEXT *out)
+static void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const VkMemoryHostPointerPropertiesEXT32 *in, VkMemoryHostPointerPropertiesEXT *out)
 {
     if (!in) return;

@@ -28274,14 +28268,14 @@ static inline void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(const VkMemoryHostPointerPropertiesEXT *in, VkMemoryHostPointerPropertiesEXT32 *out)
+static void convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(const VkMemoryHostPointerPropertiesEXT *in, VkMemoryHostPointerPropertiesEXT32 *out)
 {
     if (!in) return;

out->memoryTypeBits = in->memoryTypeBits;
 }

-static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT32 *in, VkMicromapBuildSizesInfoEXT *out)
+static void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT32 *in, VkMicromapBuildSizesInfoEXT *out)
 {
     if (!in) return;

@@ -28294,7 +28288,7 @@ static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMic
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkMicromapBuildSizesInfoEXT_host_to_win32(const VkMicromapBuildSizesInfoEXT *in, VkMicromapBuildSizesInfoEXT32 *out)
+static void convert_VkMicromapBuildSizesInfoEXT_host_to_win32(const VkMicromapBuildSizesInfoEXT *in, VkMicromapBuildSizesInfoEXT32 *out)
 {
     if (!in) return;

@@ -28303,7 +28297,13 @@ static inline void convert_VkMicromapBuildSizesInfoEXT_host_to_win32(const VkMic
     out->discardable = in->discardable;
 }

-static inline void convert_VkPerformanceValueDataINTEL_host_to_win32(const VkPerformanceValueDataINTEL *in, VkPerformanceValueDataINTEL32 *out, VkFlags selector)
+static void convert_VkPartitionedAccelerationStructureInstancesInputNV_host_to_win32(const VkPartitionedAccelerationStructureInstancesInputNV *in, const VkPartitionedAccelerationStructureInstancesInputNV32 *out)
+{
+    if (!in) return;
+
+}
+
+static void convert_VkPerformanceValueDataINTEL_host_to_win32(const VkPerformanceValueDataINTEL *in, VkPerformanceValueDataINTEL32 *out, VkFlags selector)
 {
     if (!in) return;

@@ -28317,7 +28317,7 @@ static inline void convert_VkPerformanceValueDataINTEL_host_to_win32(const VkPer
         out->valueBool = in->valueBool;
 }

-static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerformanceValueINTEL *in, VkPerformanceValueINTEL32 *out)
+static void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerformanceValueINTEL *in, VkPerformanceValueINTEL32 *out)
 {
     if (!in) return;

@@ -28325,7 +28325,7 @@ static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerform
     convert_VkPerformanceValueDataINTEL_host_to_win32(&in->data, &out->data, in->type);
 }

-static inline void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_win32_to_host(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV *out)
+static void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_win32_to_host(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV *out)
 {
     if (!in) return;

@@ -28335,23 +28335,7 @@ static inline void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_win
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_host_to_win32(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *out)
-{
-    if (!in) return;
-
-    out->MGranularity = in->MGranularity;
-    out->NGranularity = in->NGranularity;
-    out->KGranularity = in->KGranularity;
-    out->AType = in->AType;
-    out->BType = in->BType;
-    out->CType = in->CType;
-    out->ResultType = in->ResultType;
-    out->saturatingAccumulation = in->saturatingAccumulation;
-    out->scope = in->scope;
-    out->workgroupInvocations = in->workgroupInvocations;
-}
-
-static inline VkCooperativeMatrixFlexibleDimensionsPropertiesNV *convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *in, uint32_t count)
+static VkCooperativeMatrixFlexibleDimensionsPropertiesNV *convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *in, uint32_t count)
 {
     VkCooperativeMatrixFlexibleDimensionsPropertiesNV *out;
     unsigned int i;
@@ -28367,7 +28351,23 @@ static inline VkCooperativeMatrixFlexibleDimensionsPropertiesNV *convert_VkCoope
     return out;
 }

-static inline void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_array_host_to_win32(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *out, uint32_t count)
+static void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_host_to_win32(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *out)
+{
+    if (!in) return;
+
+    out->MGranularity = in->MGranularity;
+    out->NGranularity = in->NGranularity;
+    out->KGranularity = in->KGranularity;
+    out->AType = in->AType;
+    out->BType = in->BType;
+    out->CType = in->CType;
+    out->ResultType = in->ResultType;
+    out->saturatingAccumulation = in->saturatingAccumulation;
+    out->scope = in->scope;
+    out->workgroupInvocations = in->workgroupInvocations;
+}
+
+static void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_array_host_to_win32(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *out, uint32_t count)
 {
     unsigned int i;

@@ -28379,7 +28379,7 @@ static inline void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_arr
     }
 }

-static inline void convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(const VkCooperativeMatrixPropertiesKHR32 *in, VkCooperativeMatrixPropertiesKHR *out)
+static void convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(const VkCooperativeMatrixPropertiesKHR32 *in, VkCooperativeMatrixPropertiesKHR *out)
 {
     if (!in) return;

@@ -28389,22 +28389,7 @@ static inline void convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(const
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCooperativeMatrixPropertiesKHR_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out)
-{
-    if (!in) return;
-
-    out->MSize = in->MSize;
-    out->NSize = in->NSize;
-    out->KSize = in->KSize;
-    out->AType = in->AType;
-    out->BType = in->BType;
-    out->CType = in->CType;
-    out->ResultType = in->ResultType;
-    out->saturatingAccumulation = in->saturatingAccumulation;
-    out->scope = in->scope;
-}
-
-static inline VkCooperativeMatrixPropertiesKHR *convert_VkCooperativeMatrixPropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesKHR32 *in, uint32_t count)
+static VkCooperativeMatrixPropertiesKHR *convert_VkCooperativeMatrixPropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesKHR32 *in, uint32_t count)
 {
     VkCooperativeMatrixPropertiesKHR *out;
     unsigned int i;
@@ -28417,10 +28402,25 @@ static inline VkCooperativeMatrixPropertiesKHR *convert_VkCooperativeMatrixPrope
         convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(&in[i], &out[i]);
     }

-    return out;
+    return out;
+}
+
+static void convert_VkCooperativeMatrixPropertiesKHR_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out)
+{
+    if (!in) return;
+
+    out->MSize = in->MSize;
+    out->NSize = in->NSize;
+    out->KSize = in->KSize;
+    out->AType = in->AType;
+    out->BType = in->BType;
+    out->CType = in->CType;
+    out->ResultType = in->ResultType;
+    out->saturatingAccumulation = in->saturatingAccumulation;
+    out->scope = in->scope;
 }

-static inline void convert_VkCooperativeMatrixPropertiesKHR_array_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out, uint32_t count)
+static void convert_VkCooperativeMatrixPropertiesKHR_array_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out, uint32_t count)
 {
     unsigned int i;

@@ -28432,7 +28432,7 @@ static inline void convert_VkCooperativeMatrixPropertiesKHR_array_host_to_win32(
     }
 }

-static inline void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const VkCooperativeMatrixPropertiesNV32 *in, VkCooperativeMatrixPropertiesNV *out)
+static void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const VkCooperativeMatrixPropertiesNV32 *in, VkCooperativeMatrixPropertiesNV *out)
 {
     if (!in) return;

@@ -28442,21 +28442,7 @@ static inline void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const V
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCooperativeMatrixPropertiesNV_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out)
-{
-    if (!in) return;
-
-    out->MSize = in->MSize;
-    out->NSize = in->NSize;
-    out->KSize = in->KSize;
-    out->AType = in->AType;
-    out->BType = in->BType;
-    out->CType = in->CType;
-    out->DType = in->DType;
-    out->scope = in->scope;
-}
-
-static inline VkCooperativeMatrixPropertiesNV *convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesNV32 *in, uint32_t count)
+static VkCooperativeMatrixPropertiesNV *convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesNV32 *in, uint32_t count)
 {
     VkCooperativeMatrixPropertiesNV *out;
     unsigned int i;
@@ -28472,7 +28458,21 @@ static inline VkCooperativeMatrixPropertiesNV *convert_VkCooperativeMatrixProper
     return out;
 }

-static inline void convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out, uint32_t count)
+static void convert_VkCooperativeMatrixPropertiesNV_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out)
+{
+    if (!in) return;
+
+    out->MSize = in->MSize;
+    out->NSize = in->NSize;
+    out->KSize = in->KSize;
+    out->AType = in->AType;
+    out->BType = in->BType;
+    out->CType = in->CType;
+    out->DType = in->DType;
+    out->scope = in->scope;
+}
+
+static void convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out, uint32_t count)
 {
     unsigned int i;

@@ -28484,7 +28484,7 @@ static inline void convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(c
     }
 }

-static inline void convert_VkCooperativeVectorPropertiesNV_win32_to_host(const VkCooperativeVectorPropertiesNV32 *in, VkCooperativeVectorPropertiesNV *out)
+static void convert_VkCooperativeVectorPropertiesNV_win32_to_host(const VkCooperativeVectorPropertiesNV32 *in, VkCooperativeVectorPropertiesNV *out)
 {
     if (!in) return;

@@ -28500,19 +28500,7 @@ static inline void convert_VkCooperativeVectorPropertiesNV_win32_to_host(const V
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCooperativeVectorPropertiesNV_host_to_win32(const VkCooperativeVectorPropertiesNV *in, VkCooperativeVectorPropertiesNV32 *out)
-{
-    if (!in) return;
-
-    out->inputType = in->inputType;
-    out->inputInterpretation = in->inputInterpretation;
-    out->matrixInterpretation = in->matrixInterpretation;
-    out->biasInterpretation = in->biasInterpretation;
-    out->resultType = in->resultType;
-    out->transpose = in->transpose;
-}
-
-static inline VkCooperativeVectorPropertiesNV *convert_VkCooperativeVectorPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeVectorPropertiesNV32 *in, uint32_t count)
+static VkCooperativeVectorPropertiesNV *convert_VkCooperativeVectorPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeVectorPropertiesNV32 *in, uint32_t count)
 {
     VkCooperativeVectorPropertiesNV *out;
     unsigned int i;
@@ -28528,7 +28516,19 @@ static inline VkCooperativeVectorPropertiesNV *convert_VkCooperativeVectorProper
     return out;
 }

-static inline void convert_VkCooperativeVectorPropertiesNV_array_host_to_win32(const VkCooperativeVectorPropertiesNV *in, VkCooperativeVectorPropertiesNV32 *out, uint32_t count)
+static void convert_VkCooperativeVectorPropertiesNV_host_to_win32(const VkCooperativeVectorPropertiesNV *in, VkCooperativeVectorPropertiesNV32 *out)
+{
+    if (!in) return;
+
+    out->inputType = in->inputType;
+    out->inputInterpretation = in->inputInterpretation;
+    out->matrixInterpretation = in->matrixInterpretation;
+    out->biasInterpretation = in->biasInterpretation;
+    out->resultType = in->resultType;
+    out->transpose = in->transpose;
+}
+
+static void convert_VkCooperativeVectorPropertiesNV_array_host_to_win32(const VkCooperativeVectorPropertiesNV *in, VkCooperativeVectorPropertiesNV32 *out, uint32_t count)
 {
     unsigned int i;

@@ -28540,7 +28540,7 @@ static inline void convert_VkCooperativeVectorPropertiesNV_array_host_to_win32(c
     }
 }

-static inline void convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalBufferInfo32 *in, VkPhysicalDeviceExternalBufferInfo *out)
+static void convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalBufferInfo32 *in, VkPhysicalDeviceExternalBufferInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -28575,7 +28575,7 @@ static inline void convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(stru
     }
 }

-static inline void convert_VkExternalBufferProperties_win32_to_host(const VkExternalBufferProperties32 *in, VkExternalBufferProperties *out)
+static void convert_VkExternalBufferProperties_win32_to_host(const VkExternalBufferProperties32 *in, VkExternalBufferProperties *out)
 {
     if (!in) return;

@@ -28585,14 +28585,14 @@ static inline void convert_VkExternalBufferProperties_win32_to_host(const VkExte
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkExternalBufferProperties_host_to_win32(const VkExternalBufferProperties *in, VkExternalBufferProperties32 *out)
+static void convert_VkExternalBufferProperties_host_to_win32(const VkExternalBufferProperties *in, VkExternalBufferProperties32 *out)
 {
     if (!in) return;

out->externalMemoryProperties = in->externalMemoryProperties;
 }

-static inline void convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(const VkPhysicalDeviceExternalFenceInfo32 *in, VkPhysicalDeviceExternalFenceInfo *out)
+static void convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(const VkPhysicalDeviceExternalFenceInfo32 *in, VkPhysicalDeviceExternalFenceInfo *out)
 {
     if (!in) return;

@@ -28603,7 +28603,7 @@ static inline void convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(const
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkExternalFenceProperties_win32_to_host(const VkExternalFenceProperties32 *in, VkExternalFenceProperties *out)
+static void convert_VkExternalFenceProperties_win32_to_host(const VkExternalFenceProperties32 *in, VkExternalFenceProperties *out)
 {
     if (!in) return;

@@ -28613,7 +28613,7 @@ static inline void convert_VkExternalFenceProperties_win32_to_host(const VkExter
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkExternalFenceProperties_host_to_win32(const VkExternalFenceProperties *in, VkExternalFenceProperties32 *out)
+static void convert_VkExternalFenceProperties_host_to_win32(const VkExternalFenceProperties *in, VkExternalFenceProperties32 *out)
 {
     if (!in) return;

@@ -28622,7 +28622,7 @@ static inline void convert_VkExternalFenceProperties_host_to_win32(const VkExter
     out->externalFenceFeatures = in->externalFenceFeatures;
 }

-static inline void convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalSemaphoreInfo32 *in, VkPhysicalDeviceExternalSemaphoreInfo *out)
+static void convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalSemaphoreInfo32 *in, VkPhysicalDeviceExternalSemaphoreInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -28656,7 +28656,7 @@ static inline void convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(s
     }
 }

-static inline void convert_VkExternalSemaphoreProperties_win32_to_host(const VkExternalSemaphoreProperties32 *in, VkExternalSemaphoreProperties *out)
+static void convert_VkExternalSemaphoreProperties_win32_to_host(const VkExternalSemaphoreProperties32 *in, VkExternalSemaphoreProperties *out)
 {
     if (!in) return;

@@ -28666,7 +28666,7 @@ static inline void convert_VkExternalSemaphoreProperties_win32_to_host(const VkE
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkExternalSemaphoreProperties_host_to_win32(const VkExternalSemaphoreProperties *in, VkExternalSemaphoreProperties32 *out)
+static void convert_VkExternalSemaphoreProperties_host_to_win32(const VkExternalSemaphoreProperties *in, VkExternalSemaphoreProperties32 *out)
 {
     if (!in) return;

@@ -28675,7 +28675,7 @@ static inline void convert_VkExternalSemaphoreProperties_host_to_win32(const VkE
     out->externalSemaphoreFeatures = in->externalSemaphoreFeatures;
 }

-static inline void convert_VkPhysicalDeviceExternalTensorInfoARM_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalTensorInfoARM32 *in, VkPhysicalDeviceExternalTensorInfoARM *out)
+static void convert_VkPhysicalDeviceExternalTensorInfoARM_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalTensorInfoARM32 *in, VkPhysicalDeviceExternalTensorInfoARM *out)
 {
     if (!in) return;

@@ -28688,7 +28688,7 @@ static inline void convert_VkPhysicalDeviceExternalTensorInfoARM_win32_to_host(s
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkExternalTensorPropertiesARM_win32_to_host(const VkExternalTensorPropertiesARM32 *in, VkExternalTensorPropertiesARM *out)
+static void convert_VkExternalTensorPropertiesARM_win32_to_host(const VkExternalTensorPropertiesARM32 *in, VkExternalTensorPropertiesARM *out)
 {
     if (!in) return;

@@ -28699,14 +28699,14 @@ static inline void convert_VkExternalTensorPropertiesARM_win32_to_host(const VkE
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkExternalTensorPropertiesARM_host_to_win32(const VkExternalTensorPropertiesARM *in, VkExternalTensorPropertiesARM32 *out)
+static void convert_VkExternalTensorPropertiesARM_host_to_win32(const VkExternalTensorPropertiesARM *in, VkExternalTensorPropertiesARM32 *out)
 {
     if (!in) return;

out->externalMemoryProperties = in->externalMemoryProperties;
 }

-static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFeatures232 *in, VkPhysicalDeviceFeatures2 *out)
+static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFeatures232 *in, VkPhysicalDeviceFeatures2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -31416,7 +31416,7 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver
     }
 }

-static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDeviceFeatures2 *in, VkPhysicalDeviceFeatures232 *out)
+static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDeviceFeatures2 *in, VkPhysicalDeviceFeatures232 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -33689,7 +33689,7 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi
     }
 }

-static inline void convert_VkFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkFormatProperties232 *in, VkFormatProperties2 *out)
+static void convert_VkFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkFormatProperties232 *in, VkFormatProperties2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -33737,7 +33737,7 @@ static inline void convert_VkFormatProperties2_win32_to_host(struct conversion_c
     }
 }

-static inline void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2 *in, VkFormatProperties232 *out)
+static void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2 *in, VkFormatProperties232 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -33786,7 +33786,7 @@ static inline void convert_VkFormatProperties2_host_to_win32(const VkFormatPrope
     }
 }

-static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(const VkPhysicalDeviceFragmentShadingRateKHR32 *in, VkPhysicalDeviceFragmentShadingRateKHR *out)
+static void convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(const VkPhysicalDeviceFragmentShadingRateKHR32 *in, VkPhysicalDeviceFragmentShadingRateKHR *out)
 {
     if (!in) return;

@@ -33796,15 +33796,7 @@ static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out)
-{
-    if (!in) return;
-
-    out->sampleCounts = in->sampleCounts;
-    out->fragmentSize = in->fragmentSize;
-}
-
-static inline VkPhysicalDeviceFragmentShadingRateKHR *convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFragmentShadingRateKHR32 *in, uint32_t count)
+static VkPhysicalDeviceFragmentShadingRateKHR *convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFragmentShadingRateKHR32 *in, uint32_t count)
 {
     VkPhysicalDeviceFragmentShadingRateKHR *out;
     unsigned int i;
@@ -33820,7 +33812,15 @@ static inline VkPhysicalDeviceFragmentShadingRateKHR *convert_VkPhysicalDeviceFr
     return out;
 }

-static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out, uint32_t count)
+static void convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out)
+{
+    if (!in) return;
+
+    out->sampleCounts = in->sampleCounts;
+    out->fragmentSize = in->fragmentSize;
+}
+
+static void convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out, uint32_t count)
 {
     unsigned int i;

@@ -33832,7 +33832,7 @@ static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_
     }
 }

-static inline void convert_VkImageFormatProperties_host_to_win32(const VkImageFormatProperties *in, VkImageFormatProperties32 *out)
+static void convert_VkImageFormatProperties_host_to_win32(const VkImageFormatProperties *in, VkImageFormatProperties32 *out)
 {
     if (!in) return;

@@ -33843,7 +33843,7 @@ static inline void convert_VkImageFormatProperties_host_to_win32(const VkImageFo
     out->maxResourceSize = in->maxResourceSize;
 }

-static inline void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceImageFormatInfo232 *in, VkPhysicalDeviceImageFormatInfo2 *out)
+static void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceImageFormatInfo232 *in, VkPhysicalDeviceImageFormatInfo2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -33950,7 +33950,7 @@ static inline void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct
     }
 }

-static inline void convert_VkImageFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkImageFormatProperties232 *in, VkImageFormatProperties2 *out)
+static void convert_VkImageFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkImageFormatProperties232 *in, VkImageFormatProperties2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -34025,7 +34025,7 @@ static inline void convert_VkImageFormatProperties2_win32_to_host(struct convers
     }
 }

-static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatProperties2 *in, VkImageFormatProperties232 *out)
+static void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatProperties2 *in, VkImageFormatProperties232 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -34101,7 +34101,7 @@ static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageF
     }
 }

-static inline void convert_VkMemoryHeap_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out)
+static void convert_VkMemoryHeap_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out)
 {
     if (!in) return;

@@ -34109,7 +34109,7 @@ static inline void convert_VkMemoryHeap_host_to_win32(const VkMemoryHeap *in, Vk
     out->flags = in->flags;
 }

-static inline void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out, uint32_t count)
+static void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out, uint32_t count)
 {
     unsigned int i;

@@ -34121,7 +34121,7 @@ static inline void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap *
     }
 }

-static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const VkPhysicalDeviceMemoryProperties *in, VkPhysicalDeviceMemoryProperties32 *out)
+static void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const VkPhysicalDeviceMemoryProperties *in, VkPhysicalDeviceMemoryProperties32 *out)
 {
     if (!in) return;

@@ -34131,7 +34131,7 @@ static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const
     convert_VkMemoryHeap_array_host_to_win32(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
 }

-static inline void convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceMemoryProperties232 *in, VkPhysicalDeviceMemoryProperties2 *out)
+static void convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceMemoryProperties232 *in, VkPhysicalDeviceMemoryProperties2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -34161,7 +34161,7 @@ static inline void convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(struc
     }
 }

-static inline void convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(const VkPhysicalDeviceMemoryProperties2 *in, VkPhysicalDeviceMemoryProperties232 *out)
+static void convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(const VkPhysicalDeviceMemoryProperties2 *in, VkPhysicalDeviceMemoryProperties232 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -34190,7 +34190,7 @@ static inline void convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(const
     }
 }

-static inline void convert_VkMultisamplePropertiesEXT_win32_to_host(const VkMultisamplePropertiesEXT32 *in, VkMultisamplePropertiesEXT *out)
+static void convert_VkMultisamplePropertiesEXT_win32_to_host(const VkMultisamplePropertiesEXT32 *in, VkMultisamplePropertiesEXT *out)
 {
     if (!in) return;

@@ -34200,14 +34200,14 @@ static inline void convert_VkMultisamplePropertiesEXT_win32_to_host(const VkMult
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkMultisamplePropertiesEXT_host_to_win32(const VkMultisamplePropertiesEXT *in, VkMultisamplePropertiesEXT32 *out)
+static void convert_VkMultisamplePropertiesEXT_host_to_win32(const VkMultisamplePropertiesEXT *in, VkMultisamplePropertiesEXT32 *out)
 {
     if (!in) return;

out->maxSampleLocationGridSize = in->maxSampleLocationGridSize;
 }

-static inline void convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(const VkOpticalFlowImageFormatInfoNV32 *in, VkOpticalFlowImageFormatInfoNV *out)
+static void convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(const VkOpticalFlowImageFormatInfoNV32 *in, VkOpticalFlowImageFormatInfoNV *out)
 {
     if (!in) return;

@@ -34218,7 +34218,7 @@ static inline void convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(const Vk
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(const VkOpticalFlowImageFormatPropertiesNV32 *in, VkOpticalFlowImageFormatPropertiesNV *out)
+static void convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(const VkOpticalFlowImageFormatPropertiesNV32 *in, VkOpticalFlowImageFormatPropertiesNV *out)
 {
     if (!in) return;

@@ -34228,14 +34228,7 @@ static inline void convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(co
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out)
-{
-    if (!in) return;
-
-    out->format = in->format;
-}
-
-static inline VkOpticalFlowImageFormatPropertiesNV *convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowImageFormatPropertiesNV32 *in, uint32_t count)
+static VkOpticalFlowImageFormatPropertiesNV *convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowImageFormatPropertiesNV32 *in, uint32_t count)
 {
     VkOpticalFlowImageFormatPropertiesNV *out;
     unsigned int i;
@@ -34251,7 +34244,14 @@ static inline VkOpticalFlowImageFormatPropertiesNV *convert_VkOpticalFlowImageFo
     return out;
 }

-static inline void convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out, uint32_t count)
+static void convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out)
+{
+    if (!in) return;
+
+    out->format = in->format;
+}
+
+static void convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out, uint32_t count)
 {
     unsigned int i;

@@ -34263,7 +34263,7 @@ static inline void convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_wi
     }
 }

-static inline void convert_VkPhysicalDeviceLimits_host_to_win32(const VkPhysicalDeviceLimits *in, VkPhysicalDeviceLimits32 *out)
+static void convert_VkPhysicalDeviceLimits_host_to_win32(const VkPhysicalDeviceLimits *in, VkPhysicalDeviceLimits32 *out)
 {
     if (!in) return;

@@ -34375,7 +34375,7 @@ static inline void convert_VkPhysicalDeviceLimits_host_to_win32(const VkPhysical
     out->nonCoherentAtomSize = in->nonCoherentAtomSize;
 }

-static inline void convert_VkPhysicalDeviceProperties_host_to_win32(const VkPhysicalDeviceProperties *in, VkPhysicalDeviceProperties32 *out)
+static void convert_VkPhysicalDeviceProperties_host_to_win32(const VkPhysicalDeviceProperties *in, VkPhysicalDeviceProperties32 *out)
 {
     if (!in) return;

@@ -34390,7 +34390,7 @@ static inline void convert_VkPhysicalDeviceProperties_host_to_win32(const VkPhys
     out->sparseProperties = in->sparseProperties;
 }

-static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceProperties232 *in, VkPhysicalDeviceProperties2 *out)
+static void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceProperties232 *in, VkPhysicalDeviceProperties2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -35307,7 +35307,7 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv
     }
 }

-static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDeviceProperties2 *in, VkPhysicalDeviceProperties232 *out)
+static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDeviceProperties2 *in, VkPhysicalDeviceProperties232 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -36694,7 +36694,7 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy
     }
 }

-static inline void convert_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM_win32_to_host(const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32 *in, VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *out)
+static void convert_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM_win32_to_host(const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32 *in, VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *out)
 {
     if (!in) return;

@@ -36706,7 +36706,7 @@ static inline void convert_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineI
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_win32_to_host(const VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 *in, VkQueueFamilyDataGraphProcessingEnginePropertiesARM *out)
+static void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_win32_to_host(const VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 *in, VkQueueFamilyDataGraphProcessingEnginePropertiesARM *out)
 {
     if (!in) return;

@@ -36718,7 +36718,7 @@ static inline void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_w
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_host_to_win32(const VkQueueFamilyDataGraphProcessingEnginePropertiesARM *in, VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 *out)
+static void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_host_to_win32(const VkQueueFamilyDataGraphProcessingEnginePropertiesARM *in, VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 *out)
 {
     if (!in) return;

@@ -36726,7 +36726,7 @@ static inline void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_h
     out->foreignMemoryHandleTypes = in->foreignMemoryHandleTypes;
 }

-static inline void convert_VkQueueFamilyDataGraphPropertiesARM_win32_to_host(const VkQueueFamilyDataGraphPropertiesARM32 *in, VkQueueFamilyDataGraphPropertiesARM *out)
+static void convert_VkQueueFamilyDataGraphPropertiesARM_win32_to_host(const VkQueueFamilyDataGraphPropertiesARM32 *in, VkQueueFamilyDataGraphPropertiesARM *out)
 {
     if (!in) return;

@@ -36738,15 +36738,7 @@ static inline void convert_VkQueueFamilyDataGraphPropertiesARM_win32_to_host(con
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkQueueFamilyDataGraphPropertiesARM_host_to_win32(const VkQueueFamilyDataGraphPropertiesARM *in, VkQueueFamilyDataGraphPropertiesARM32 *out)
-{
-    if (!in) return;
-
-    out->engine = in->engine;
-    out->operation = in->operation;
-}
-
-static inline VkQueueFamilyDataGraphPropertiesARM *convert_VkQueueFamilyDataGraphPropertiesARM_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyDataGraphPropertiesARM32 *in, uint32_t count)
+static VkQueueFamilyDataGraphPropertiesARM *convert_VkQueueFamilyDataGraphPropertiesARM_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyDataGraphPropertiesARM32 *in, uint32_t count)
 {
     VkQueueFamilyDataGraphPropertiesARM *out;
     unsigned int i;
@@ -36762,7 +36754,15 @@ static inline VkQueueFamilyDataGraphPropertiesARM *convert_VkQueueFamilyDataGrap
     return out;
 }

-static inline void convert_VkQueueFamilyDataGraphPropertiesARM_array_host_to_win32(const VkQueueFamilyDataGraphPropertiesARM *in, VkQueueFamilyDataGraphPropertiesARM32 *out, uint32_t count)
+static void convert_VkQueueFamilyDataGraphPropertiesARM_host_to_win32(const VkQueueFamilyDataGraphPropertiesARM *in, VkQueueFamilyDataGraphPropertiesARM32 *out)
+{
+    if (!in) return;
+
+    out->engine = in->engine;
+    out->operation = in->operation;
+}
+
+static void convert_VkQueueFamilyDataGraphPropertiesARM_array_host_to_win32(const VkQueueFamilyDataGraphPropertiesARM *in, VkQueueFamilyDataGraphPropertiesARM32 *out, uint32_t count)
 {
     unsigned int i;

@@ -36774,7 +36774,7 @@ static inline void convert_VkQueueFamilyDataGraphPropertiesARM_array_host_to_win
     }
 }

-static inline void convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(const VkQueryPoolPerformanceCreateInfoKHR32 *in, VkQueryPoolPerformanceCreateInfoKHR *out)
+static void convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(const VkQueryPoolPerformanceCreateInfoKHR32 *in, VkQueryPoolPerformanceCreateInfoKHR *out)
 {
     if (!in) return;

@@ -36787,7 +36787,7 @@ static inline void convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(con
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, VkQueueFamilyProperties2 *out)
+static void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, VkQueueFamilyProperties2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -36862,7 +36862,23 @@ static inline void convert_VkQueueFamilyProperties2_win32_to_host(struct convers
     }
 }

-static inline void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out)
+static VkQueueFamilyProperties2 *convert_VkQueueFamilyProperties2_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, uint32_t count)
+{
+    VkQueueFamilyProperties2 *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkQueueFamilyProperties2_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -36936,23 +36952,7 @@ static inline void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueF
     }
 }

-static inline VkQueueFamilyProperties2 *convert_VkQueueFamilyProperties2_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, uint32_t count)
-{
-    VkQueueFamilyProperties2 *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkQueueFamilyProperties2_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkQueueFamilyProperties2_array_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out, uint32_t count)
+static void convert_VkQueueFamilyProperties2_array_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out, uint32_t count)
 {
     unsigned int i;

@@ -36964,7 +36964,7 @@ static inline void convert_VkQueueFamilyProperties2_array_host_to_win32(const Vk
     }
 }

-static inline void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(const VkPhysicalDeviceSparseImageFormatInfo232 *in, VkPhysicalDeviceSparseImageFormatInfo2 *out)
+static void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(const VkPhysicalDeviceSparseImageFormatInfo232 *in, VkPhysicalDeviceSparseImageFormatInfo2 *out)
 {
     if (!in) return;

@@ -36979,7 +36979,7 @@ static inline void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkSparseImageFormatProperties2_win32_to_host(const VkSparseImageFormatProperties232 *in, VkSparseImageFormatProperties2 *out)
+static void convert_VkSparseImageFormatProperties2_win32_to_host(const VkSparseImageFormatProperties232 *in, VkSparseImageFormatProperties2 *out)
 {
     if (!in) return;

@@ -36989,14 +36989,7 @@ static inline void convert_VkSparseImageFormatProperties2_win32_to_host(const Vk
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkSparseImageFormatProperties2_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out)
-{
-    if (!in) return;
-
-    out->properties = in->properties;
-}
-
-static inline VkSparseImageFormatProperties2 *convert_VkSparseImageFormatProperties2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageFormatProperties232 *in, uint32_t count)
+static VkSparseImageFormatProperties2 *convert_VkSparseImageFormatProperties2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageFormatProperties232 *in, uint32_t count)
 {
     VkSparseImageFormatProperties2 *out;
     unsigned int i;
@@ -37012,7 +37005,14 @@ static inline VkSparseImageFormatProperties2 *convert_VkSparseImageFormatPropert
     return out;
 }

-static inline void convert_VkSparseImageFormatProperties2_array_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out, uint32_t count)
+static void convert_VkSparseImageFormatProperties2_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out)
+{
+    if (!in) return;
+
+    out->properties = in->properties;
+}
+
+static void convert_VkSparseImageFormatProperties2_array_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out, uint32_t count)
 {
     unsigned int i;

@@ -37024,7 +37024,7 @@ static inline void convert_VkSparseImageFormatProperties2_array_host_to_win32(co
     }
 }

-static inline void convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(const VkFramebufferMixedSamplesCombinationNV32 *in, VkFramebufferMixedSamplesCombinationNV *out)
+static void convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(const VkFramebufferMixedSamplesCombinationNV32 *in, VkFramebufferMixedSamplesCombinationNV *out)
 {
     if (!in) return;

@@ -37034,17 +37034,7 @@ static inline void convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out)
-{
-    if (!in) return;
-
-    out->coverageReductionMode = in->coverageReductionMode;
-    out->rasterizationSamples = in->rasterizationSamples;
-    out->depthStencilSamples = in->depthStencilSamples;
-    out->colorSamples = in->colorSamples;
-}
-
-static inline VkFramebufferMixedSamplesCombinationNV *convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferMixedSamplesCombinationNV32 *in, uint32_t count)
+static VkFramebufferMixedSamplesCombinationNV *convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferMixedSamplesCombinationNV32 *in, uint32_t count)
 {
     VkFramebufferMixedSamplesCombinationNV *out;
     unsigned int i;
@@ -37060,7 +37050,17 @@ static inline VkFramebufferMixedSamplesCombinationNV *convert_VkFramebufferMixed
     return out;
 }

-static inline void convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out, uint32_t count)
+static void convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out)
+{
+    if (!in) return;
+
+    out->coverageReductionMode = in->coverageReductionMode;
+    out->rasterizationSamples = in->rasterizationSamples;
+    out->depthStencilSamples = in->depthStencilSamples;
+    out->colorSamples = in->colorSamples;
+}
+
+static void convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out, uint32_t count)
 {
     unsigned int i;

@@ -37072,7 +37072,7 @@ static inline void convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_
     }
 }

-static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
+static void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -37105,7 +37105,7 @@ static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_ho
     }
 }

-static inline void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceCapabilities2KHR32 *in, VkSurfaceCapabilities2KHR *out)
+static void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceCapabilities2KHR32 *in, VkSurfaceCapabilities2KHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -37196,7 +37196,7 @@ static inline void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conver
     }
 }

-static inline void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapabilities2KHR *in, VkSurfaceCapabilities2KHR32 *out)
+static void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapabilities2KHR *in, VkSurfaceCapabilities2KHR32 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -37275,7 +37275,7 @@ static inline void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfa
     }
 }

-static inline void convert_VkSurfaceFormat2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, VkSurfaceFormat2KHR *out)
+static void convert_VkSurfaceFormat2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, VkSurfaceFormat2KHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -37305,7 +37305,23 @@ static inline void convert_VkSurfaceFormat2KHR_win32_to_host(struct conversion_c
     }
 }

-static inline void convert_VkSurfaceFormat2KHR_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out)
+static VkSurfaceFormat2KHR *convert_VkSurfaceFormat2KHR_array_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, uint32_t count)
+{
+    VkSurfaceFormat2KHR *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkSurfaceFormat2KHR_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkSurfaceFormat2KHR_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -37334,23 +37350,7 @@ static inline void convert_VkSurfaceFormat2KHR_host_to_win32(const VkSurfaceForm
     }
 }

-static inline VkSurfaceFormat2KHR *convert_VkSurfaceFormat2KHR_array_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, uint32_t count)
-{
-    VkSurfaceFormat2KHR *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkSurfaceFormat2KHR_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkSurfaceFormat2KHR_array_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out, uint32_t count)
+static void convert_VkSurfaceFormat2KHR_array_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out, uint32_t count)
 {
     unsigned int i;

@@ -37362,7 +37362,7 @@ static inline void convert_VkSurfaceFormat2KHR_array_host_to_win32(const VkSurfa
     }
 }

-static inline void convert_VkPhysicalDeviceToolProperties_win32_to_host(const VkPhysicalDeviceToolProperties32 *in, VkPhysicalDeviceToolProperties *out)
+static void convert_VkPhysicalDeviceToolProperties_win32_to_host(const VkPhysicalDeviceToolProperties32 *in, VkPhysicalDeviceToolProperties *out)
 {
     if (!in) return;

@@ -37372,18 +37372,7 @@ static inline void convert_VkPhysicalDeviceToolProperties_win32_to_host(const Vk
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPhysicalDeviceToolProperties_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out)
-{
-    if (!in) return;
-
-    memcpy(out->name, in->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-    memcpy(out->version, in->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-    out->purposes = in->purposes;
-    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    memcpy(out->layer, in->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-}
-
-static inline VkPhysicalDeviceToolProperties *convert_VkPhysicalDeviceToolProperties_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceToolProperties32 *in, uint32_t count)
+static VkPhysicalDeviceToolProperties *convert_VkPhysicalDeviceToolProperties_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceToolProperties32 *in, uint32_t count)
 {
     VkPhysicalDeviceToolProperties *out;
     unsigned int i;
@@ -37399,7 +37388,18 @@ static inline VkPhysicalDeviceToolProperties *convert_VkPhysicalDeviceToolProper
     return out;
 }

-static inline void convert_VkPhysicalDeviceToolProperties_array_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out, uint32_t count)
+static void convert_VkPhysicalDeviceToolProperties_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out)
+{
+    if (!in) return;
+
+    memcpy(out->name, in->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    memcpy(out->version, in->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    out->purposes = in->purposes;
+    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    memcpy(out->layer, in->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+}
+
+static void convert_VkPhysicalDeviceToolProperties_array_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out, uint32_t count)
 {
     unsigned int i;

@@ -37411,7 +37411,7 @@ static inline void convert_VkPhysicalDeviceToolProperties_array_host_to_win32(co
     }
 }

-static inline void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoCapabilitiesKHR32 *in, VkVideoCapabilitiesKHR *out)
+static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoCapabilitiesKHR32 *in, VkVideoCapabilitiesKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -37540,7 +37540,7 @@ static inline void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversio
     }
 }

-static inline void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabilitiesKHR *in, VkVideoCapabilitiesKHR32 *out)
+static void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabilitiesKHR *in, VkVideoCapabilitiesKHR32 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -37724,7 +37724,7 @@ static inline void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCap
     }
 }

-static inline void convert_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR32 *in, VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *out)
+static void convert_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR32 *in, VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *out)
 {
     if (!in) return;

@@ -37736,7 +37736,7 @@ static inline void convert_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR_win32_
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkVideoEncodeQualityLevelPropertiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeQualityLevelPropertiesKHR32 *in, VkVideoEncodeQualityLevelPropertiesKHR *out)
+static void convert_VkVideoEncodeQualityLevelPropertiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeQualityLevelPropertiesKHR32 *in, VkVideoEncodeQualityLevelPropertiesKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -37775,7 +37775,7 @@ static inline void convert_VkVideoEncodeQualityLevelPropertiesKHR_win32_to_host(
     }
 }

-static inline void convert_VkVideoEncodeQualityLevelPropertiesKHR_host_to_win32(const VkVideoEncodeQualityLevelPropertiesKHR *in, VkVideoEncodeQualityLevelPropertiesKHR32 *out)
+static void convert_VkVideoEncodeQualityLevelPropertiesKHR_host_to_win32(const VkVideoEncodeQualityLevelPropertiesKHR *in, VkVideoEncodeQualityLevelPropertiesKHR32 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -37835,7 +37835,7 @@ static inline void convert_VkVideoEncodeQualityLevelPropertiesKHR_host_to_win32(
     }
 }

-static inline void convert_VkPhysicalDeviceVideoFormatInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceVideoFormatInfoKHR32 *in, VkPhysicalDeviceVideoFormatInfoKHR *out)
+static void convert_VkPhysicalDeviceVideoFormatInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceVideoFormatInfoKHR32 *in, VkPhysicalDeviceVideoFormatInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -37869,7 +37869,7 @@ static inline void convert_VkPhysicalDeviceVideoFormatInfoKHR_win32_to_host(stru
     }
 }

-static inline void convert_VkVideoFormatPropertiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoFormatPropertiesKHR32 *in, VkVideoFormatPropertiesKHR *out)
+static void convert_VkVideoFormatPropertiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoFormatPropertiesKHR32 *in, VkVideoFormatPropertiesKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -37917,7 +37917,23 @@ static inline void convert_VkVideoFormatPropertiesKHR_win32_to_host(struct conve
     }
 }

-static inline void convert_VkVideoFormatPropertiesKHR_host_to_win32(const VkVideoFormatPropertiesKHR *in, VkVideoFormatPropertiesKHR32 *out)
+static VkVideoFormatPropertiesKHR *convert_VkVideoFormatPropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoFormatPropertiesKHR32 *in, uint32_t count)
+{
+    VkVideoFormatPropertiesKHR *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkVideoFormatPropertiesKHR_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static void convert_VkVideoFormatPropertiesKHR_host_to_win32(const VkVideoFormatPropertiesKHR *in, VkVideoFormatPropertiesKHR32 *out)
 {
     const VkBaseInStructure *in_header;
     VkBaseOutStructure32 *out_header = (void *)out;
@@ -37968,23 +37984,7 @@ static inline void convert_VkVideoFormatPropertiesKHR_host_to_win32(const VkVide
     }
 }

-static inline VkVideoFormatPropertiesKHR *convert_VkVideoFormatPropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoFormatPropertiesKHR32 *in, uint32_t count)
-{
-    VkVideoFormatPropertiesKHR *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkVideoFormatPropertiesKHR_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static inline void convert_VkVideoFormatPropertiesKHR_array_host_to_win32(const VkVideoFormatPropertiesKHR *in, VkVideoFormatPropertiesKHR32 *out, uint32_t count)
+static void convert_VkVideoFormatPropertiesKHR_array_host_to_win32(const VkVideoFormatPropertiesKHR *in, VkVideoFormatPropertiesKHR32 *out, uint32_t count)
 {
     unsigned int i;

@@ -37996,7 +37996,7 @@ static inline void convert_VkVideoFormatPropertiesKHR_array_host_to_win32(const
     }
 }

-static inline void convert_VkPipelineBinaryDataInfoKHR_win32_to_host(const VkPipelineBinaryDataInfoKHR32 *in, VkPipelineBinaryDataInfoKHR *out)
+static void convert_VkPipelineBinaryDataInfoKHR_win32_to_host(const VkPipelineBinaryDataInfoKHR32 *in, VkPipelineBinaryDataInfoKHR *out)
 {
     if (!in) return;

@@ -38007,7 +38007,7 @@ static inline void convert_VkPipelineBinaryDataInfoKHR_win32_to_host(const VkPip
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPipelineBinaryKeyKHR_host_to_win32(const VkPipelineBinaryKeyKHR *in, VkPipelineBinaryKeyKHR32 *out)
+static void convert_VkPipelineBinaryKeyKHR_host_to_win32(const VkPipelineBinaryKeyKHR *in, VkPipelineBinaryKeyKHR32 *out)
 {
     if (!in) return;

@@ -38015,7 +38015,7 @@ static inline void convert_VkPipelineBinaryKeyKHR_host_to_win32(const VkPipeline
     memcpy(out->key, in->key, VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR * sizeof(uint8_t));
 }

-static inline void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPipelineExecutableInfoKHR32 *in, VkPipelineExecutableInfoKHR *out)
+static void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPipelineExecutableInfoKHR32 *in, VkPipelineExecutableInfoKHR *out)
 {
     if (!in) return;

@@ -38027,7 +38027,7 @@ static inline void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPip
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(const VkPipelineExecutableInternalRepresentationKHR32 *in, VkPipelineExecutableInternalRepresentationKHR *out)
+static void convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(const VkPipelineExecutableInternalRepresentationKHR32 *in, VkPipelineExecutableInternalRepresentationKHR *out)
 {
     if (!in) return;

@@ -38037,18 +38037,7 @@ static inline void convert_VkPipelineExecutableInternalRepresentationKHR_win32_t
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out)
-{
-    if (!in) return;
-
-    memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    out->isText = in->isText;
-    out->dataSize = in->dataSize;
-    out->pData = PtrToUlong(in->pData);
-}
-
-static inline VkPipelineExecutableInternalRepresentationKHR *convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableInternalRepresentationKHR32 *in, uint32_t count)
+static VkPipelineExecutableInternalRepresentationKHR *convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableInternalRepresentationKHR32 *in, uint32_t count)
 {
     VkPipelineExecutableInternalRepresentationKHR *out;
     unsigned int i;
@@ -38064,7 +38053,18 @@ static inline VkPipelineExecutableInternalRepresentationKHR *convert_VkPipelineE
     return out;
 }

-static inline void convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out, uint32_t count)
+static void convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out)
+{
+    if (!in) return;
+
+    memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    out->isText = in->isText;
+    out->dataSize = in->dataSize;
+    out->pData = PtrToUlong(in->pData);
+}
+
+static void convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out, uint32_t count)
 {
     unsigned int i;

@@ -38076,7 +38076,7 @@ static inline void convert_VkPipelineExecutableInternalRepresentationKHR_array_h
     }
 }

-static inline void convert_VkPipelineInfoKHR_win32_to_host(const VkPipelineInfoKHR32 *in, VkPipelineInfoKHR *out)
+static void convert_VkPipelineInfoKHR_win32_to_host(const VkPipelineInfoKHR32 *in, VkPipelineInfoKHR *out)
 {
     if (!in) return;

@@ -38087,7 +38087,7 @@ static inline void convert_VkPipelineInfoKHR_win32_to_host(const VkPipelineInfoK
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPipelineExecutablePropertiesKHR_win32_to_host(const VkPipelineExecutablePropertiesKHR32 *in, VkPipelineExecutablePropertiesKHR *out)
+static void convert_VkPipelineExecutablePropertiesKHR_win32_to_host(const VkPipelineExecutablePropertiesKHR32 *in, VkPipelineExecutablePropertiesKHR *out)
 {
     if (!in) return;

@@ -38097,17 +38097,7 @@ static inline void convert_VkPipelineExecutablePropertiesKHR_win32_to_host(const
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPipelineExecutablePropertiesKHR_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out)
-{
-    if (!in) return;
-
-    out->stages = in->stages;
-    memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    out->subgroupSize = in->subgroupSize;
-}
-
-static inline VkPipelineExecutablePropertiesKHR *convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutablePropertiesKHR32 *in, uint32_t count)
+static VkPipelineExecutablePropertiesKHR *convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutablePropertiesKHR32 *in, uint32_t count)
 {
     VkPipelineExecutablePropertiesKHR *out;
     unsigned int i;
@@ -38123,7 +38113,17 @@ static inline VkPipelineExecutablePropertiesKHR *convert_VkPipelineExecutablePro
     return out;
 }

-static inline void convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out, uint32_t count)
+static void convert_VkPipelineExecutablePropertiesKHR_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out)
+{
+    if (!in) return;
+
+    out->stages = in->stages;
+    memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    out->subgroupSize = in->subgroupSize;
+}
+
+static void convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out, uint32_t count)
 {
     unsigned int i;

@@ -38135,21 +38135,7 @@ static inline void convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32
     }
 }

-static inline void convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(const VkPipelineExecutableStatisticValueKHR *in, VkPipelineExecutableStatisticValueKHR32 *out, VkFlags selector)
-{
-    if (!in) return;
-
-    if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR)
-        out->b32 = in->b32;
-    if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR)
-        out->i64 = in->i64;
-    if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR)
-        out->u64 = in->u64;
-    if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR)
-        out->f64 = in->f64;
-}
-
-static inline void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const VkPipelineExecutableStatisticKHR32 *in, VkPipelineExecutableStatisticKHR *out)
+static void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const VkPipelineExecutableStatisticKHR32 *in, VkPipelineExecutableStatisticKHR *out)
 {
     if (!in) return;

@@ -38159,17 +38145,7 @@ static inline void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPipelineExecutableStatisticKHR_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out)
-{
-    if (!in) return;
-
-    memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    out->format = in->format;
-    convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(&in->value, &out->value, in->format);
-}
-
-static inline VkPipelineExecutableStatisticKHR *convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableStatisticKHR32 *in, uint32_t count)
+static VkPipelineExecutableStatisticKHR *convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableStatisticKHR32 *in, uint32_t count)
 {
     VkPipelineExecutableStatisticKHR *out;
     unsigned int i;
@@ -38185,7 +38161,31 @@ static inline VkPipelineExecutableStatisticKHR *convert_VkPipelineExecutableStat
     return out;
 }

-static inline void convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out, uint32_t count)
+static void convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(const VkPipelineExecutableStatisticValueKHR *in, VkPipelineExecutableStatisticValueKHR32 *out, VkFlags selector)
+{
+    if (!in) return;
+
+    if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR)
+        out->b32 = in->b32;
+    if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR)
+        out->i64 = in->i64;
+    if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR)
+        out->u64 = in->u64;
+    if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR)
+        out->f64 = in->f64;
+}
+
+static void convert_VkPipelineExecutableStatisticKHR_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out)
+{
+    if (!in) return;
+
+    memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    out->format = in->format;
+    convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(&in->value, &out->value, in->format);
+}
+
+static void convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out, uint32_t count)
 {
     unsigned int i;

@@ -38197,7 +38197,7 @@ static inline void convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(
     }
 }

-static inline void convert_VkPipelineIndirectDeviceAddressInfoNV_win32_to_host(const VkPipelineIndirectDeviceAddressInfoNV32 *in, VkPipelineIndirectDeviceAddressInfoNV *out)
+static void convert_VkPipelineIndirectDeviceAddressInfoNV_win32_to_host(const VkPipelineIndirectDeviceAddressInfoNV32 *in, VkPipelineIndirectDeviceAddressInfoNV *out)
 {
     if (!in) return;

@@ -38209,7 +38209,7 @@ static inline void convert_VkPipelineIndirectDeviceAddressInfoNV_win32_to_host(c
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoEXT32 *in, VkPipelineInfoEXT *out)
+static void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoEXT32 *in, VkPipelineInfoEXT *out)
 {
     if (!in) return;

@@ -38220,7 +38220,7 @@ static inline void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoE
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCheckpointData2NV_win32_to_host(const VkCheckpointData2NV32 *in, VkCheckpointData2NV *out)
+static void convert_VkCheckpointData2NV_win32_to_host(const VkCheckpointData2NV32 *in, VkCheckpointData2NV *out)
 {
     if (!in) return;

@@ -38230,15 +38230,7 @@ static inline void convert_VkCheckpointData2NV_win32_to_host(const VkCheckpointD
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCheckpointData2NV_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out)
-{
-    if (!in) return;
-
-    out->stage = in->stage;
-    out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
-}
-
-static inline VkCheckpointData2NV *convert_VkCheckpointData2NV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointData2NV32 *in, uint32_t count)
+static VkCheckpointData2NV *convert_VkCheckpointData2NV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointData2NV32 *in, uint32_t count)
 {
     VkCheckpointData2NV *out;
     unsigned int i;
@@ -38254,7 +38246,15 @@ static inline VkCheckpointData2NV *convert_VkCheckpointData2NV_array_win32_to_ho
     return out;
 }

-static inline void convert_VkCheckpointData2NV_array_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out, uint32_t count)
+static void convert_VkCheckpointData2NV_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out)
+{
+    if (!in) return;
+
+    out->stage = in->stage;
+    out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
+}
+
+static void convert_VkCheckpointData2NV_array_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out, uint32_t count)
 {
     unsigned int i;

@@ -38266,7 +38266,7 @@ static inline void convert_VkCheckpointData2NV_array_host_to_win32(const VkCheck
     }
 }

-static inline void convert_VkCheckpointDataNV_win32_to_host(const VkCheckpointDataNV32 *in, VkCheckpointDataNV *out)
+static void convert_VkCheckpointDataNV_win32_to_host(const VkCheckpointDataNV32 *in, VkCheckpointDataNV *out)
 {
     if (!in) return;

@@ -38276,15 +38276,7 @@ static inline void convert_VkCheckpointDataNV_win32_to_host(const VkCheckpointDa
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCheckpointDataNV_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out)
-{
-    if (!in) return;
-
-    out->stage = in->stage;
-    out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
-}
-
-static inline VkCheckpointDataNV *convert_VkCheckpointDataNV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointDataNV32 *in, uint32_t count)
+static VkCheckpointDataNV *convert_VkCheckpointDataNV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointDataNV32 *in, uint32_t count)
 {
     VkCheckpointDataNV *out;
     unsigned int i;
@@ -38300,7 +38292,15 @@ static inline VkCheckpointDataNV *convert_VkCheckpointDataNV_array_win32_to_host
     return out;
 }

-static inline void convert_VkCheckpointDataNV_array_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out, uint32_t count)
+static void convert_VkCheckpointDataNV_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out)
+{
+    if (!in) return;
+
+    out->stage = in->stage;
+    out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
+}
+
+static void convert_VkCheckpointDataNV_array_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out, uint32_t count)
 {
     unsigned int i;

@@ -38312,7 +38312,7 @@ static inline void convert_VkCheckpointDataNV_array_host_to_win32(const VkCheckp
     }
 }

-static inline void convert_VkRenderingAreaInfo_win32_to_host(const VkRenderingAreaInfo32 *in, VkRenderingAreaInfo *out)
+static void convert_VkRenderingAreaInfo_win32_to_host(const VkRenderingAreaInfo32 *in, VkRenderingAreaInfo *out)
 {
     if (!in) return;

@@ -38327,7 +38327,7 @@ static inline void convert_VkRenderingAreaInfo_win32_to_host(const VkRenderingAr
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host(const VkSamplerCaptureDescriptorDataInfoEXT32 *in, VkSamplerCaptureDescriptorDataInfoEXT *out)
+static void convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host(const VkSamplerCaptureDescriptorDataInfoEXT32 *in, VkSamplerCaptureDescriptorDataInfoEXT *out)
 {
     if (!in) return;

@@ -38338,7 +38338,7 @@ static inline void convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host(c
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkShaderModuleIdentifierEXT_win32_to_host(const VkShaderModuleIdentifierEXT32 *in, VkShaderModuleIdentifierEXT *out)
+static void convert_VkShaderModuleIdentifierEXT_win32_to_host(const VkShaderModuleIdentifierEXT32 *in, VkShaderModuleIdentifierEXT *out)
 {
     if (!in) return;

@@ -38348,7 +38348,7 @@ static inline void convert_VkShaderModuleIdentifierEXT_win32_to_host(const VkSha
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkShaderModuleIdentifierEXT_host_to_win32(const VkShaderModuleIdentifierEXT *in, VkShaderModuleIdentifierEXT32 *out)
+static void convert_VkShaderModuleIdentifierEXT_host_to_win32(const VkShaderModuleIdentifierEXT *in, VkShaderModuleIdentifierEXT32 *out)
 {
     if (!in) return;

@@ -38356,7 +38356,7 @@ static inline void convert_VkShaderModuleIdentifierEXT_host_to_win32(const VkSha
     memcpy(out->identifier, in->identifier, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t));
 }

-static inline void convert_VkTensorMemoryRequirementsInfoARM_win32_to_host(const VkTensorMemoryRequirementsInfoARM32 *in, VkTensorMemoryRequirementsInfoARM *out)
+static void convert_VkTensorMemoryRequirementsInfoARM_win32_to_host(const VkTensorMemoryRequirementsInfoARM32 *in, VkTensorMemoryRequirementsInfoARM *out)
 {
     if (!in) return;

@@ -38367,7 +38367,7 @@ static inline void convert_VkTensorMemoryRequirementsInfoARM_win32_to_host(const
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkTensorCaptureDescriptorDataInfoARM_win32_to_host(const VkTensorCaptureDescriptorDataInfoARM32 *in, VkTensorCaptureDescriptorDataInfoARM *out)
+static void convert_VkTensorCaptureDescriptorDataInfoARM_win32_to_host(const VkTensorCaptureDescriptorDataInfoARM32 *in, VkTensorCaptureDescriptorDataInfoARM *out)
 {
     if (!in) return;

@@ -38378,7 +38378,7 @@ static inline void convert_VkTensorCaptureDescriptorDataInfoARM_win32_to_host(co
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkTensorViewCaptureDescriptorDataInfoARM_win32_to_host(const VkTensorViewCaptureDescriptorDataInfoARM32 *in, VkTensorViewCaptureDescriptorDataInfoARM *out)
+static void convert_VkTensorViewCaptureDescriptorDataInfoARM_win32_to_host(const VkTensorViewCaptureDescriptorDataInfoARM32 *in, VkTensorViewCaptureDescriptorDataInfoARM *out)
 {
     if (!in) return;

@@ -38389,7 +38389,7 @@ static inline void convert_VkTensorViewCaptureDescriptorDataInfoARM_win32_to_hos
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkVideoSessionMemoryRequirementsKHR_win32_to_host(const VkVideoSessionMemoryRequirementsKHR32 *in, VkVideoSessionMemoryRequirementsKHR *out)
+static void convert_VkVideoSessionMemoryRequirementsKHR_win32_to_host(const VkVideoSessionMemoryRequirementsKHR32 *in, VkVideoSessionMemoryRequirementsKHR *out)
 {
     if (!in) return;

@@ -38399,15 +38399,7 @@ static inline void convert_VkVideoSessionMemoryRequirementsKHR_win32_to_host(con
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkVideoSessionMemoryRequirementsKHR_host_to_win32(const VkVideoSessionMemoryRequirementsKHR *in, VkVideoSessionMemoryRequirementsKHR32 *out)
-{
-    if (!in) return;
-
-    out->memoryBindIndex = in->memoryBindIndex;
-    convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
-}
-
-static inline VkVideoSessionMemoryRequirementsKHR *convert_VkVideoSessionMemoryRequirementsKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoSessionMemoryRequirementsKHR32 *in, uint32_t count)
+static VkVideoSessionMemoryRequirementsKHR *convert_VkVideoSessionMemoryRequirementsKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoSessionMemoryRequirementsKHR32 *in, uint32_t count)
 {
     VkVideoSessionMemoryRequirementsKHR *out;
     unsigned int i;
@@ -38423,7 +38415,15 @@ static inline VkVideoSessionMemoryRequirementsKHR *convert_VkVideoSessionMemoryR
     return out;
 }

-static inline void convert_VkVideoSessionMemoryRequirementsKHR_array_host_to_win32(const VkVideoSessionMemoryRequirementsKHR *in, VkVideoSessionMemoryRequirementsKHR32 *out, uint32_t count)
+static void convert_VkVideoSessionMemoryRequirementsKHR_host_to_win32(const VkVideoSessionMemoryRequirementsKHR *in, VkVideoSessionMemoryRequirementsKHR32 *out)
+{
+    if (!in) return;
+
+    out->memoryBindIndex = in->memoryBindIndex;
+    convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
+}
+
+static void convert_VkVideoSessionMemoryRequirementsKHR_array_host_to_win32(const VkVideoSessionMemoryRequirementsKHR *in, VkVideoSessionMemoryRequirementsKHR32 *out, uint32_t count)
 {
     unsigned int i;

@@ -38435,7 +38435,7 @@ static inline void convert_VkVideoSessionMemoryRequirementsKHR_array_host_to_win
     }
 }

-static inline void convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(const VkInitializePerformanceApiInfoINTEL32 *in, VkInitializePerformanceApiInfoINTEL *out)
+static void convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(const VkInitializePerformanceApiInfoINTEL32 *in, VkInitializePerformanceApiInfoINTEL *out)
 {
     if (!in) return;

@@ -38446,7 +38446,7 @@ static inline void convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(con
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkLatencySleepInfoNV_win32_to_host(const VkLatencySleepInfoNV32 *in, VkLatencySleepInfoNV *out)
+static void convert_VkLatencySleepInfoNV_win32_to_host(const VkLatencySleepInfoNV32 *in, VkLatencySleepInfoNV *out)
 {
     if (!in) return;

@@ -38459,7 +38459,7 @@ static inline void convert_VkLatencySleepInfoNV_win32_to_host(const VkLatencySle
 }

#ifdef _WIN64
-static inline void convert_VkMemoryMapInfo_win64_to_host(const VkMemoryMapInfo *in, VkMemoryMapInfo *out)
+static void convert_VkMemoryMapInfo_win64_to_host(const VkMemoryMapInfo *in, VkMemoryMapInfo *out)
 {
     if (!in) return;

@@ -38472,7 +38472,7 @@ static inline void convert_VkMemoryMapInfo_win64_to_host(const VkMemoryMapInfo *
 }
 #endif /* _WIN64 */

-static inline void convert_VkMemoryMapInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryMapInfo32 *in, VkMemoryMapInfo *out)
+static void convert_VkMemoryMapInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryMapInfo32 *in, VkMemoryMapInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -38508,7 +38508,7 @@ static inline void convert_VkMemoryMapInfo_win32_to_host(struct conversion_conte
     }
 }

-static inline void convert_VkMemoryMapInfo_win32_to_unwrapped_host(struct conversion_context *ctx, const VkMemoryMapInfo32 *in, VkMemoryMapInfo *out)
+static void convert_VkMemoryMapInfo_win32_to_unwrapped_host(struct conversion_context *ctx, const VkMemoryMapInfo32 *in, VkMemoryMapInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -38545,7 +38545,7 @@ static inline void convert_VkMemoryMapInfo_win32_to_unwrapped_host(struct conver
 }

#ifdef _WIN64
-static inline void convert_VkSparseMemoryBind_win64_to_host(const VkSparseMemoryBind *in, VkSparseMemoryBind *out)
+static void convert_VkSparseMemoryBind_win64_to_host(const VkSparseMemoryBind *in, VkSparseMemoryBind *out)
 {
     if (!in) return;

@@ -38557,19 +38557,8 @@ static inline void convert_VkSparseMemoryBind_win64_to_host(const VkSparseMemory
 }
 #endif /* _WIN64 */

-static inline void convert_VkSparseMemoryBind_win32_to_host(const VkSparseMemoryBind32 *in, VkSparseMemoryBind *out)
-{
-    if (!in) return;
-
-    out->resourceOffset = in->resourceOffset;
-    out->size = in->size;
-    out->memory = in->memory ? vulkan_device_memory_from_handle(in->memory)->host.device_memory : 0;
-    out->memoryOffset = in->memoryOffset;
-    out->flags = in->flags;
-}
-
 #ifdef _WIN64
-static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseMemoryBind *in, uint32_t count)
+static const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseMemoryBind *in, uint32_t count)
 {
     VkSparseMemoryBind *out;
     unsigned int i;
@@ -38586,9 +38575,21 @@ static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win64_t
 }
 #endif /* _WIN64 */

-static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseMemoryBind32 *in, uint32_t count)
+#ifdef _WIN64
+static void convert_VkSparseBufferMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, VkSparseBufferMemoryBindInfo *out)
 {
-    VkSparseMemoryBind *out;
+    if (!in) return;
+
+    out->buffer = in->buffer;
+    out->bindCount = in->bindCount;
+    out->pBinds = convert_VkSparseMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
+}
+#endif /* _WIN64 */
+
+#ifdef _WIN64
+static const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, uint32_t count)
+{
+    VkSparseBufferMemoryBindInfo *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -38596,36 +38597,28 @@ static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win32_t
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkSparseMemoryBind_win32_to_host(&in[i], &out[i]);
+        convert_VkSparseBufferMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
+#endif /* _WIN64 */

#ifdef _WIN64
-static inline void convert_VkSparseBufferMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, VkSparseBufferMemoryBindInfo *out)
+static void convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, VkSparseImageOpaqueMemoryBindInfo *out)
 {
     if (!in) return;

-    out->buffer = in->buffer;
+    out->image = in->image;
     out->bindCount = in->bindCount;
     out->pBinds = convert_VkSparseMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
 }
 #endif /* _WIN64 */

-static inline void convert_VkSparseBufferMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, VkSparseBufferMemoryBindInfo *out)
-{
-    if (!in) return;
-
-    out->buffer = in->buffer;
-    out->bindCount = in->bindCount;
-    out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
-}
-
 #ifdef _WIN64
-static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, uint32_t count)
+static const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, uint32_t count)
 {
-    VkSparseBufferMemoryBindInfo *out;
+    VkSparseImageOpaqueMemoryBindInfo *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -38633,16 +38626,31 @@ static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBi
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkSparseBufferMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
+        convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
 #endif /* _WIN64 */

-static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, uint32_t count)
+#ifdef _WIN64
+static void convert_VkSparseImageMemoryBind_win64_to_host(const VkSparseImageMemoryBind *in, VkSparseImageMemoryBind *out)
 {
-    VkSparseBufferMemoryBindInfo *out;
+    if (!in) return;
+
+    out->subresource = in->subresource;
+    out->offset = in->offset;
+    out->extent = in->extent;
+    out->memory = in->memory ? vulkan_device_memory_from_handle(in->memory)->host.device_memory : 0;
+    out->memoryOffset = in->memoryOffset;
+    out->flags = in->flags;
+}
+#endif /* _WIN64 */
+
+#ifdef _WIN64
+static const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind *in, uint32_t count)
+{
+    VkSparseImageMemoryBind *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -38650,36 +38658,66 @@ static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBi
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkSparseBufferMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
+        convert_VkSparseImageMemoryBind_win64_to_host(&in[i], &out[i]);
     }

return out;
 }
+#endif /* _WIN64 */

#ifdef _WIN64
-static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, VkSparseImageOpaqueMemoryBindInfo *out)
+static void convert_VkSparseImageMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, VkSparseImageMemoryBindInfo *out)
 {
     if (!in) return;

out->image = in->image;
     out->bindCount = in->bindCount;
-    out->pBinds = convert_VkSparseMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
+    out->pBinds = convert_VkSparseImageMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
+}
+#endif /* _WIN64 */
+
+#ifdef _WIN64
+static const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, uint32_t count)
+{
+    VkSparseImageMemoryBindInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkSparseImageMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
 }
 #endif /* _WIN64 */

-static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, VkSparseImageOpaqueMemoryBindInfo *out)
+#ifdef _WIN64
+static void convert_VkBindSparseInfo_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, VkBindSparseInfo *out)
 {
     if (!in) return;

-    out->image = in->image;
-    out->bindCount = in->bindCount;
-    out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->waitSemaphoreCount = in->waitSemaphoreCount;
+    out->pWaitSemaphores = in->pWaitSemaphores;
+    out->bufferBindCount = in->bufferBindCount;
+    out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(ctx, in->pBufferBinds, in->bufferBindCount);
+    out->imageOpaqueBindCount = in->imageOpaqueBindCount;
+    out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(ctx, in->pImageOpaqueBinds, in->imageOpaqueBindCount);
+    out->imageBindCount = in->imageBindCount;
+    out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win64_to_host(ctx, in->pImageBinds, in->imageBindCount);
+    out->signalSemaphoreCount = in->signalSemaphoreCount;
+    out->pSignalSemaphores = in->pSignalSemaphores;
 }
+#endif /* _WIN64 */

#ifdef _WIN64
-static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, uint32_t count)
+static const VkBindSparseInfo *convert_VkBindSparseInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, uint32_t count)
 {
-    VkSparseImageOpaqueMemoryBindInfo *out;
+    VkBindSparseInfo *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -38687,16 +38725,27 @@ static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaq
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
+        convert_VkBindSparseInfo_win64_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
 #endif /* _WIN64 */

-static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, uint32_t count)
+static void convert_VkSparseMemoryBind_win32_to_host(const VkSparseMemoryBind32 *in, VkSparseMemoryBind *out)
 {
-    VkSparseImageOpaqueMemoryBindInfo *out;
+    if (!in) return;
+
+    out->resourceOffset = in->resourceOffset;
+    out->size = in->size;
+    out->memory = in->memory ? vulkan_device_memory_from_handle(in->memory)->host.device_memory : 0;
+    out->memoryOffset = in->memoryOffset;
+    out->flags = in->flags;
+}
+
+static const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseMemoryBind32 *in, uint32_t count)
+{
+    VkSparseMemoryBind *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -38704,42 +38753,49 @@ static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaq
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
+        convert_VkSparseMemoryBind_win32_to_host(&in[i], &out[i]);
     }

return out;
 }

-#ifdef _WIN64
-static inline void convert_VkSparseImageMemoryBind_win64_to_host(const VkSparseImageMemoryBind *in, VkSparseImageMemoryBind *out)
+static void convert_VkSparseBufferMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, VkSparseBufferMemoryBindInfo *out)
 {
     if (!in) return;

-    out->subresource = in->subresource;
-    out->offset = in->offset;
-    out->extent = in->extent;
-    out->memory = in->memory ? vulkan_device_memory_from_handle(in->memory)->host.device_memory : 0;
-    out->memoryOffset = in->memoryOffset;
-    out->flags = in->flags;
+    out->buffer = in->buffer;
+    out->bindCount = in->bindCount;
+    out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
+}
+
+static const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, uint32_t count)
+{
+    VkSparseBufferMemoryBindInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkSparseBufferMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
 }
-#endif /* _WIN64 */

-static inline void convert_VkSparseImageMemoryBind_win32_to_host(const VkSparseImageMemoryBind32 *in, VkSparseImageMemoryBind *out)
+static void convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, VkSparseImageOpaqueMemoryBindInfo *out)
 {
     if (!in) return;

-    out->subresource = in->subresource;
-    out->offset = in->offset;
-    out->extent = in->extent;
-    out->memory = in->memory ? vulkan_device_memory_from_handle(in->memory)->host.device_memory : 0;
-    out->memoryOffset = in->memoryOffset;
-    out->flags = in->flags;
+    out->image = in->image;
+    out->bindCount = in->bindCount;
+    out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
 }

-#ifdef _WIN64
-static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind *in, uint32_t count)
+static const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, uint32_t count)
 {
-    VkSparseImageMemoryBind *out;
+    VkSparseImageOpaqueMemoryBindInfo *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -38747,14 +38803,25 @@ static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_arr
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkSparseImageMemoryBind_win64_to_host(&in[i], &out[i]);
+        convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
-#endif /* _WIN64 */

-static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind32 *in, uint32_t count)
+static void convert_VkSparseImageMemoryBind_win32_to_host(const VkSparseImageMemoryBind32 *in, VkSparseImageMemoryBind *out)
+{
+    if (!in) return;
+
+    out->subresource = in->subresource;
+    out->offset = in->offset;
+    out->extent = in->extent;
+    out->memory = in->memory ? vulkan_device_memory_from_handle(in->memory)->host.device_memory : 0;
+    out->memoryOffset = in->memoryOffset;
+    out->flags = in->flags;
+}
+
+static const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind32 *in, uint32_t count)
 {
     VkSparseImageMemoryBind *out;
     unsigned int i;
@@ -38770,18 +38837,7 @@ static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_arr
     return out;
 }

-#ifdef _WIN64
-static inline void convert_VkSparseImageMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, VkSparseImageMemoryBindInfo *out)
-{
-    if (!in) return;
-
-    out->image = in->image;
-    out->bindCount = in->bindCount;
-    out->pBinds = convert_VkSparseImageMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
-}
-#endif /* _WIN64 */
-
-static inline void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, VkSparseImageMemoryBindInfo *out)
+static void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, VkSparseImageMemoryBindInfo *out)
 {
     if (!in) return;

@@ -38790,25 +38846,7 @@ static inline void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conv
     out->pBinds = convert_VkSparseImageMemoryBind_array_win32_to_host(ctx, (const VkSparseImageMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
 }

-#ifdef _WIN64
-static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, uint32_t count)
-{
-    VkSparseImageMemoryBindInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkSparseImageMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-#endif /* _WIN64 */
-
-static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, uint32_t count)
+static const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, uint32_t count)
 {
     VkSparseImageMemoryBindInfo *out;
     unsigned int i;
@@ -38824,27 +38862,7 @@ static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBind
     return out;
 }

-#ifdef _WIN64
-static inline void convert_VkBindSparseInfo_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, VkBindSparseInfo *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->waitSemaphoreCount = in->waitSemaphoreCount;
-    out->pWaitSemaphores = in->pWaitSemaphores;
-    out->bufferBindCount = in->bufferBindCount;
-    out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(ctx, in->pBufferBinds, in->bufferBindCount);
-    out->imageOpaqueBindCount = in->imageOpaqueBindCount;
-    out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(ctx, in->pImageOpaqueBinds, in->imageOpaqueBindCount);
-    out->imageBindCount = in->imageBindCount;
-    out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win64_to_host(ctx, in->pImageBinds, in->imageBindCount);
-    out->signalSemaphoreCount = in->signalSemaphoreCount;
-    out->pSignalSemaphores = in->pSignalSemaphores;
-}
-#endif /* _WIN64 */
-
-static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, VkBindSparseInfo *out)
+static void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, VkBindSparseInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -38932,25 +38950,7 @@ static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_cont
     }
 }

-#ifdef _WIN64
-static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, uint32_t count)
-{
-    VkBindSparseInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkBindSparseInfo_win64_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-#endif /* _WIN64 */
-
-static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, uint32_t count)
+static const VkBindSparseInfo *convert_VkBindSparseInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, uint32_t count)
 {
     VkBindSparseInfo *out;
     unsigned int i;
@@ -38966,7 +38966,7 @@ static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win32_to_ho
     return out;
 }

-static inline void convert_VkOutOfBandQueueTypeInfoNV_win32_to_host(const VkOutOfBandQueueTypeInfoNV32 *in, VkOutOfBandQueueTypeInfoNV *out)
+static void convert_VkOutOfBandQueueTypeInfoNV_win32_to_host(const VkOutOfBandQueueTypeInfoNV32 *in, VkOutOfBandQueueTypeInfoNV *out)
 {
     if (!in) return;

@@ -38977,7 +38977,7 @@ static inline void convert_VkOutOfBandQueueTypeInfoNV_win32_to_host(const VkOutO
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkPresentRegionKHR_win32_to_host(const VkPresentRegionKHR32 *in, VkPresentRegionKHR *out)
+static void convert_VkPresentRegionKHR_win32_to_host(const VkPresentRegionKHR32 *in, VkPresentRegionKHR *out)
 {
     if (!in) return;

@@ -38985,7 +38985,7 @@ static inline void convert_VkPresentRegionKHR_win32_to_host(const VkPresentRegio
     out->pRectangles = UlongToPtr(in->pRectangles);
 }

-static inline const VkPresentRegionKHR *convert_VkPresentRegionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPresentRegionKHR32 *in, uint32_t count)
+static const VkPresentRegionKHR *convert_VkPresentRegionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPresentRegionKHR32 *in, uint32_t count)
 {
     VkPresentRegionKHR *out;
     unsigned int i;
@@ -39001,7 +39001,7 @@ static inline const VkPresentRegionKHR *convert_VkPresentRegionKHR_array_win32_t
     return out;
 }

-static inline void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPresentInfoKHR32 *in, VkPresentInfoKHR *out)
+static void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPresentInfoKHR32 *in, VkPresentInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -39133,7 +39133,7 @@ static inline void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conve
 }

#ifdef _WIN64
-static inline void convert_VkSubmitInfo_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, VkSubmitInfo *out)
+static void convert_VkSubmitInfo_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, VkSubmitInfo *out)
 {
     if (!in) return;

@@ -39149,7 +39149,25 @@ static inline void convert_VkSubmitInfo_win64_to_host(struct conversion_context
 }
 #endif /* _WIN64 */

-static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, VkSubmitInfo *out)
+#ifdef _WIN64
+static const VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, uint32_t count)
+{
+    VkSubmitInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkSubmitInfo_win64_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+#endif /* _WIN64 */
+
+static void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, VkSubmitInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -39271,8 +39289,7 @@ static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context
     }
 }

-#ifdef _WIN64
-static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, uint32_t count)
+static const VkSubmitInfo *convert_VkSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, uint32_t count)
 {
     VkSubmitInfo *out;
     unsigned int i;
@@ -39282,16 +39299,28 @@ static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struc
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkSubmitInfo_win64_to_host(ctx, &in[i], &out[i]);
+        convert_VkSubmitInfo_win32_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
+
+#ifdef _WIN64
+static void convert_VkCommandBufferSubmitInfo_win64_to_host(const VkCommandBufferSubmitInfo *in, VkCommandBufferSubmitInfo *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->host.command_buffer;
+    out->deviceMask = in->deviceMask;
+}
 #endif /* _WIN64 */

-static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, uint32_t count)
+#ifdef _WIN64
+static const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo *in, uint32_t count)
 {
-    VkSubmitInfo *out;
+    VkCommandBufferSubmitInfo *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -39299,13 +39328,49 @@ static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win32_to_host(struc
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkSubmitInfo_win32_to_host(ctx, &in[i], &out[i]);
+        convert_VkCommandBufferSubmitInfo_win64_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+#endif /* _WIN64 */
+
+#ifdef _WIN64
+static void convert_VkSubmitInfo2_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, VkSubmitInfo2 *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->flags = in->flags;
+    out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
+    out->pWaitSemaphoreInfos = in->pWaitSemaphoreInfos;
+    out->commandBufferInfoCount = in->commandBufferInfoCount;
+    out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win64_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount);
+    out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
+    out->pSignalSemaphoreInfos = in->pSignalSemaphoreInfos;
+}
+#endif /* _WIN64 */
+
+#ifdef _WIN64
+static const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, uint32_t count)
+{
+    VkSubmitInfo2 *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkSubmitInfo2_win64_to_host(ctx, &in[i], &out[i]);
     }

return out;
 }
+#endif /* _WIN64 */

-static inline void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphoreSubmitInfo32 *in, VkSemaphoreSubmitInfo *out)
+static void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphoreSubmitInfo32 *in, VkSemaphoreSubmitInfo *out)
 {
     if (!in) return;

@@ -39319,7 +39384,7 @@ static inline void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphore
         FIXME("Unexpected pNext\n");
 }

-static inline const VkSemaphoreSubmitInfo *convert_VkSemaphoreSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSemaphoreSubmitInfo32 *in, uint32_t count)
+static const VkSemaphoreSubmitInfo *convert_VkSemaphoreSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSemaphoreSubmitInfo32 *in, uint32_t count)
 {
     VkSemaphoreSubmitInfo *out;
     unsigned int i;
@@ -39335,19 +39400,7 @@ static inline const VkSemaphoreSubmitInfo *convert_VkSemaphoreSubmitInfo_array_w
     return out;
 }

-#ifdef _WIN64
-static inline void convert_VkCommandBufferSubmitInfo_win64_to_host(const VkCommandBufferSubmitInfo *in, VkCommandBufferSubmitInfo *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->host.command_buffer;
-    out->deviceMask = in->deviceMask;
-}
-#endif /* _WIN64 */
-
-static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, VkCommandBufferSubmitInfo *out)
+static void convert_VkCommandBufferSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, VkCommandBufferSubmitInfo *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -39382,25 +39435,7 @@ static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(struct conver
     }
 }

-#ifdef _WIN64
-static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo *in, uint32_t count)
-{
-    VkCommandBufferSubmitInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkCommandBufferSubmitInfo_win64_to_host(&in[i], &out[i]);
-    }
-
-    return out;
-}
-#endif /* _WIN64 */
-
-static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, uint32_t count)
+static const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, uint32_t count)
 {
     VkCommandBufferSubmitInfo *out;
     unsigned int i;
@@ -39416,24 +39451,7 @@ static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo
     return out;
 }

-#ifdef _WIN64
-static inline void convert_VkSubmitInfo2_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, VkSubmitInfo2 *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->flags = in->flags;
-    out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
-    out->pWaitSemaphoreInfos = in->pWaitSemaphoreInfos;
-    out->commandBufferInfoCount = in->commandBufferInfoCount;
-    out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win64_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount);
-    out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
-    out->pSignalSemaphoreInfos = in->pSignalSemaphoreInfos;
-}
-#endif /* _WIN64 */
-
-static inline void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, VkSubmitInfo2 *out)
+static void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, VkSubmitInfo2 *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -39514,25 +39532,7 @@ static inline void convert_VkSubmitInfo2_win32_to_host(struct conversion_context
     }
 }

-#ifdef _WIN64
-static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, uint32_t count)
-{
-    VkSubmitInfo2 *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_VkSubmitInfo2_win64_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-#endif /* _WIN64 */
-
-static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, uint32_t count)
+static const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, uint32_t count)
 {
     VkSubmitInfo2 *out;
     unsigned int i;
@@ -39548,7 +39548,7 @@ static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win32_to_host(str
     return out;
 }

-static inline void convert_VkReleaseCapturedPipelineDataInfoKHR_win32_to_host(const VkReleaseCapturedPipelineDataInfoKHR32 *in, VkReleaseCapturedPipelineDataInfoKHR *out)
+static void convert_VkReleaseCapturedPipelineDataInfoKHR_win32_to_host(const VkReleaseCapturedPipelineDataInfoKHR32 *in, VkReleaseCapturedPipelineDataInfoKHR *out)
 {
     if (!in) return;

@@ -39560,7 +39560,7 @@ static inline void convert_VkReleaseCapturedPipelineDataInfoKHR_win32_to_host(co
 }

#ifdef _WIN64
-static inline void convert_VkReleaseSwapchainImagesInfoKHR_win64_to_host(const VkReleaseSwapchainImagesInfoKHR *in, VkReleaseSwapchainImagesInfoKHR *out)
+static void convert_VkReleaseSwapchainImagesInfoKHR_win64_to_host(const VkReleaseSwapchainImagesInfoKHR *in, VkReleaseSwapchainImagesInfoKHR *out)
 {
     if (!in) return;

@@ -39572,7 +39572,7 @@ static inline void convert_VkReleaseSwapchainImagesInfoKHR_win64_to_host(const V
 }
 #endif /* _WIN64 */

-static inline void convert_VkReleaseSwapchainImagesInfoKHR_win32_to_host(const VkReleaseSwapchainImagesInfoKHR32 *in, VkReleaseSwapchainImagesInfoKHR *out)
+static void convert_VkReleaseSwapchainImagesInfoKHR_win32_to_host(const VkReleaseSwapchainImagesInfoKHR32 *in, VkReleaseSwapchainImagesInfoKHR *out)
 {
     if (!in) return;

@@ -39586,7 +39586,7 @@ static inline void convert_VkReleaseSwapchainImagesInfoKHR_win32_to_host(const V
 }

#ifdef _WIN64
-static inline void convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(const VkDebugUtilsObjectNameInfoEXT *in, VkDebugUtilsObjectNameInfoEXT *out)
+static void convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(const VkDebugUtilsObjectNameInfoEXT *in, VkDebugUtilsObjectNameInfoEXT *out)
 {
     if (!in) return;

@@ -39598,7 +39598,7 @@ static inline void convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(const VkD
 }
 #endif /* _WIN64 */

-static inline void convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(const VkDebugUtilsObjectNameInfoEXT32 *in, VkDebugUtilsObjectNameInfoEXT *out)
+static void convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(const VkDebugUtilsObjectNameInfoEXT32 *in, VkDebugUtilsObjectNameInfoEXT *out)
 {
     if (!in) return;

@@ -39612,7 +39612,7 @@ static inline void convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(const VkD
 }

#ifdef _WIN64
-static inline void convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(const VkDebugUtilsObjectTagInfoEXT *in, VkDebugUtilsObjectTagInfoEXT *out)
+static void convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(const VkDebugUtilsObjectTagInfoEXT *in, VkDebugUtilsObjectTagInfoEXT *out)
 {
     if (!in) return;

@@ -39626,7 +39626,7 @@ static inline void convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(const VkDe
 }
 #endif /* _WIN64 */

-static inline void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDebugUtilsObjectTagInfoEXT32 *in, VkDebugUtilsObjectTagInfoEXT *out)
+static void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDebugUtilsObjectTagInfoEXT32 *in, VkDebugUtilsObjectTagInfoEXT *out)
 {
     if (!in) return;

@@ -39642,7 +39642,7 @@ static inline void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDe
 }

#ifdef _WIN64
-static inline const VkSwapchainKHR *convert_VkSwapchainKHR_array_win64_to_host(struct conversion_context *ctx, const VkSwapchainKHR *in, uint32_t count)
+static const VkSwapchainKHR *convert_VkSwapchainKHR_array_win64_to_host(struct conversion_context *ctx, const VkSwapchainKHR *in, uint32_t count)
 {
     VkSwapchainKHR *out;
     unsigned int i;
@@ -39659,7 +39659,7 @@ static inline const VkSwapchainKHR *convert_VkSwapchainKHR_array_win64_to_host(s
 }
 #endif /* _WIN64 */

-static inline const VkSwapchainKHR *convert_VkSwapchainKHR_array_win32_to_host(struct conversion_context *ctx, const VkSwapchainKHR *in, uint32_t count)
+static const VkSwapchainKHR *convert_VkSwapchainKHR_array_win32_to_host(struct conversion_context *ctx, const VkSwapchainKHR *in, uint32_t count)
 {
     VkSwapchainKHR *out;
     unsigned int i;
@@ -39675,7 +39675,7 @@ static inline const VkSwapchainKHR *convert_VkSwapchainKHR_array_win32_to_host(s
     return out;
 }

-static inline void convert_VkHdrMetadataEXT_win32_to_host(struct conversion_context *ctx, const VkHdrMetadataEXT32 *in, VkHdrMetadataEXT *out)
+static void convert_VkHdrMetadataEXT_win32_to_host(struct conversion_context *ctx, const VkHdrMetadataEXT32 *in, VkHdrMetadataEXT *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -39716,7 +39716,7 @@ static inline void convert_VkHdrMetadataEXT_win32_to_host(struct conversion_cont
     }
 }

-static inline const VkHdrMetadataEXT *convert_VkHdrMetadataEXT_array_win32_to_host(struct conversion_context *ctx, const VkHdrMetadataEXT32 *in, uint32_t count)
+static const VkHdrMetadataEXT *convert_VkHdrMetadataEXT_array_win32_to_host(struct conversion_context *ctx, const VkHdrMetadataEXT32 *in, uint32_t count)
 {
     VkHdrMetadataEXT *out;
     unsigned int i;
@@ -39732,7 +39732,7 @@ static inline const VkHdrMetadataEXT *convert_VkHdrMetadataEXT_array_win32_to_ho
     return out;
 }

-static inline void convert_VkSetLatencyMarkerInfoNV_win32_to_host(const VkSetLatencyMarkerInfoNV32 *in, VkSetLatencyMarkerInfoNV *out)
+static void convert_VkSetLatencyMarkerInfoNV_win32_to_host(const VkSetLatencyMarkerInfoNV32 *in, VkSetLatencyMarkerInfoNV *out)
 {
     if (!in) return;

@@ -39744,7 +39744,7 @@ static inline void convert_VkSetLatencyMarkerInfoNV_win32_to_host(const VkSetLat
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkLatencySleepModeInfoNV_win32_to_host(const VkLatencySleepModeInfoNV32 *in, VkLatencySleepModeInfoNV *out)
+static void convert_VkLatencySleepModeInfoNV_win32_to_host(const VkLatencySleepModeInfoNV32 *in, VkLatencySleepModeInfoNV *out)
 {
     if (!in) return;

@@ -39757,7 +39757,7 @@ static inline void convert_VkLatencySleepModeInfoNV_win32_to_host(const VkLatenc
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkSemaphoreSignalInfo_win32_to_host(const VkSemaphoreSignalInfo32 *in, VkSemaphoreSignalInfo *out)
+static void convert_VkSemaphoreSignalInfo_win32_to_host(const VkSemaphoreSignalInfo32 *in, VkSemaphoreSignalInfo *out)
 {
     if (!in) return;

@@ -39769,9 +39769,10 @@ static inline void convert_VkSemaphoreSignalInfo_win32_to_host(const VkSemaphore
         FIXME("Unexpected pNext\n");
 }

-static inline const VkDebugUtilsLabelEXT *convert_VkDebugUtilsLabelEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsLabelEXT32 *in, uint32_t count)
+#ifdef _WIN64
+static const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT *in, uint32_t count)
 {
-    VkDebugUtilsLabelEXT *out;
+    VkDebugUtilsObjectNameInfoEXT *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -39779,16 +39780,36 @@ static inline const VkDebugUtilsLabelEXT *convert_VkDebugUtilsLabelEXT_array_win
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkDebugUtilsLabelEXT_win32_to_host(&in[i], &out[i]);
+        convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(&in[i], &out[i]);
     }

return out;
 }
+#endif /* _WIN64 */

#ifdef _WIN64
-static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT *in, uint32_t count)
+static void convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT *in, VkDebugUtilsMessengerCallbackDataEXT *out)
 {
-    VkDebugUtilsObjectNameInfoEXT *out;
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = in->pNext;
+    out->flags = in->flags;
+    out->pMessageIdName = in->pMessageIdName;
+    out->messageIdNumber = in->messageIdNumber;
+    out->pMessage = in->pMessage;
+    out->queueLabelCount = in->queueLabelCount;
+    out->pQueueLabels = in->pQueueLabels;
+    out->cmdBufLabelCount = in->cmdBufLabelCount;
+    out->pCmdBufLabels = in->pCmdBufLabels;
+    out->objectCount = in->objectCount;
+    out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(ctx, in->pObjects, in->objectCount);
+}
+#endif /* _WIN64 */
+
+static const VkDebugUtilsLabelEXT *convert_VkDebugUtilsLabelEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsLabelEXT32 *in, uint32_t count)
+{
+    VkDebugUtilsLabelEXT *out;
     unsigned int i;

if (!in || !count) return NULL;
@@ -39796,14 +39817,13 @@ static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNam
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(&in[i], &out[i]);
+        convert_VkDebugUtilsLabelEXT_win32_to_host(&in[i], &out[i]);
     }

return out;
 }
-#endif /* _WIN64 */

-static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT32 *in, uint32_t count)
+static const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT32 *in, uint32_t count)
 {
     VkDebugUtilsObjectNameInfoEXT *out;
     unsigned int i;
@@ -39819,27 +39839,7 @@ static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNam
     return out;
 }

-#ifdef _WIN64
-static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT *in, VkDebugUtilsMessengerCallbackDataEXT *out)
-{
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->flags = in->flags;
-    out->pMessageIdName = in->pMessageIdName;
-    out->messageIdNumber = in->messageIdNumber;
-    out->pMessage = in->pMessage;
-    out->queueLabelCount = in->queueLabelCount;
-    out->pQueueLabels = in->pQueueLabels;
-    out->cmdBufLabelCount = in->cmdBufLabelCount;
-    out->pCmdBufLabels = in->pCmdBufLabels;
-    out->objectCount = in->objectCount;
-    out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(ctx, in->pObjects, in->objectCount);
-}
-#endif /* _WIN64 */
-
-static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT32 *in, VkDebugUtilsMessengerCallbackDataEXT *out)
+static void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT32 *in, VkDebugUtilsMessengerCallbackDataEXT *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -39884,7 +39884,7 @@ static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(st
     }
 }

-static inline void convert_VkHostImageLayoutTransitionInfo_win32_to_host(const VkHostImageLayoutTransitionInfo32 *in, VkHostImageLayoutTransitionInfo *out)
+static void convert_VkHostImageLayoutTransitionInfo_win32_to_host(const VkHostImageLayoutTransitionInfo32 *in, VkHostImageLayoutTransitionInfo *out)
 {
     if (!in) return;

@@ -39898,7 +39898,7 @@ static inline void convert_VkHostImageLayoutTransitionInfo_win32_to_host(const V
         FIXME("Unexpected pNext\n");
 }

-static inline const VkHostImageLayoutTransitionInfo *convert_VkHostImageLayoutTransitionInfo_array_win32_to_host(struct conversion_context *ctx, const VkHostImageLayoutTransitionInfo32 *in, uint32_t count)
+static const VkHostImageLayoutTransitionInfo *convert_VkHostImageLayoutTransitionInfo_array_win32_to_host(struct conversion_context *ctx, const VkHostImageLayoutTransitionInfo32 *in, uint32_t count)
 {
     VkHostImageLayoutTransitionInfo *out;
     unsigned int i;
@@ -39915,7 +39915,7 @@ static inline const VkHostImageLayoutTransitionInfo *convert_VkHostImageLayoutTr
 }

#ifdef _WIN64
-static inline void convert_VkMemoryUnmapInfo_win64_to_host(const VkMemoryUnmapInfo *in, VkMemoryUnmapInfo *out)
+static void convert_VkMemoryUnmapInfo_win64_to_host(const VkMemoryUnmapInfo *in, VkMemoryUnmapInfo *out)
 {
     if (!in) return;

@@ -39926,7 +39926,7 @@ static inline void convert_VkMemoryUnmapInfo_win64_to_host(const VkMemoryUnmapIn
 }
 #endif /* _WIN64 */

-static inline void convert_VkMemoryUnmapInfo_win32_to_host(const VkMemoryUnmapInfo32 *in, VkMemoryUnmapInfo *out)
+static void convert_VkMemoryUnmapInfo_win32_to_host(const VkMemoryUnmapInfo32 *in, VkMemoryUnmapInfo *out)
 {
     if (!in) return;

@@ -39938,7 +39938,7 @@ static inline void convert_VkMemoryUnmapInfo_win32_to_host(const VkMemoryUnmapIn
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkMemoryUnmapInfo_win32_to_unwrapped_host(const VkMemoryUnmapInfo32 *in, VkMemoryUnmapInfo *out)
+static void convert_VkMemoryUnmapInfo_win32_to_unwrapped_host(const VkMemoryUnmapInfo32 *in, VkMemoryUnmapInfo *out)
 {
     if (!in) return;

@@ -39950,7 +39950,7 @@ static inline void convert_VkMemoryUnmapInfo_win32_to_unwrapped_host(const VkMem
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescriptorSet32 *in, VkCopyDescriptorSet *out)
+static void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescriptorSet32 *in, VkCopyDescriptorSet *out)
 {
     if (!in) return;

@@ -39967,7 +39967,7 @@ static inline void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescrip
         FIXME("Unexpected pNext\n");
 }

-static inline const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkCopyDescriptorSet32 *in, uint32_t count)
+static const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkCopyDescriptorSet32 *in, uint32_t count)
 {
     VkCopyDescriptorSet *out;
     unsigned int i;
@@ -39983,7 +39983,7 @@ static inline const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32
     return out;
 }

-static inline void convert_VkWriteIndirectExecutionSetPipelineEXT_win32_to_host(const VkWriteIndirectExecutionSetPipelineEXT32 *in, VkWriteIndirectExecutionSetPipelineEXT *out)
+static void convert_VkWriteIndirectExecutionSetPipelineEXT_win32_to_host(const VkWriteIndirectExecutionSetPipelineEXT32 *in, VkWriteIndirectExecutionSetPipelineEXT *out)
 {
     if (!in) return;

@@ -39995,7 +39995,7 @@ static inline void convert_VkWriteIndirectExecutionSetPipelineEXT_win32_to_host(
         FIXME("Unexpected pNext\n");
 }

-static inline const VkWriteIndirectExecutionSetPipelineEXT *convert_VkWriteIndirectExecutionSetPipelineEXT_array_win32_to_host(struct conversion_context *ctx, const VkWriteIndirectExecutionSetPipelineEXT32 *in, uint32_t count)
+static const VkWriteIndirectExecutionSetPipelineEXT *convert_VkWriteIndirectExecutionSetPipelineEXT_array_win32_to_host(struct conversion_context *ctx, const VkWriteIndirectExecutionSetPipelineEXT32 *in, uint32_t count)
 {
     VkWriteIndirectExecutionSetPipelineEXT *out;
     unsigned int i;
@@ -40011,7 +40011,7 @@ static inline const VkWriteIndirectExecutionSetPipelineEXT *convert_VkWriteIndir
     return out;
 }

-static inline void convert_VkWriteIndirectExecutionSetShaderEXT_win32_to_host(const VkWriteIndirectExecutionSetShaderEXT32 *in, VkWriteIndirectExecutionSetShaderEXT *out)
+static void convert_VkWriteIndirectExecutionSetShaderEXT_win32_to_host(const VkWriteIndirectExecutionSetShaderEXT32 *in, VkWriteIndirectExecutionSetShaderEXT *out)
 {
     if (!in) return;

@@ -40023,7 +40023,7 @@ static inline void convert_VkWriteIndirectExecutionSetShaderEXT_win32_to_host(co
         FIXME("Unexpected pNext\n");
 }

-static inline const VkWriteIndirectExecutionSetShaderEXT *convert_VkWriteIndirectExecutionSetShaderEXT_array_win32_to_host(struct conversion_context *ctx, const VkWriteIndirectExecutionSetShaderEXT32 *in, uint32_t count)
+static const VkWriteIndirectExecutionSetShaderEXT *convert_VkWriteIndirectExecutionSetShaderEXT_array_win32_to_host(struct conversion_context *ctx, const VkWriteIndirectExecutionSetShaderEXT32 *in, uint32_t count)
 {
     VkWriteIndirectExecutionSetShaderEXT *out;
     unsigned int i;
@@ -40039,7 +40039,7 @@ static inline const VkWriteIndirectExecutionSetShaderEXT *convert_VkWriteIndirec
     return out;
 }

-static inline void convert_VkVideoSessionParametersUpdateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionParametersUpdateInfoKHR32 *in, VkVideoSessionParametersUpdateInfoKHR *out)
+static void convert_VkVideoSessionParametersUpdateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionParametersUpdateInfoKHR32 *in, VkVideoSessionParametersUpdateInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
     VkBaseOutStructure *out_header = (void *)out;
@@ -40089,7 +40089,7 @@ static inline void convert_VkVideoSessionParametersUpdateInfoKHR_win32_to_host(s
     }
 }

-static inline void convert_VkPresentWait2InfoKHR_win32_to_host(const VkPresentWait2InfoKHR32 *in, VkPresentWait2InfoKHR *out)
+static void convert_VkPresentWait2InfoKHR_win32_to_host(const VkPresentWait2InfoKHR32 *in, VkPresentWait2InfoKHR *out)
 {
     if (!in) return;

@@ -40101,7 +40101,7 @@ static inline void convert_VkPresentWait2InfoKHR_win32_to_host(const VkPresentWa
         FIXME("Unexpected pNext\n");
 }

-static inline void convert_VkSemaphoreWaitInfo_win32_to_host(const VkSemaphoreWaitInfo32 *in, VkSemaphoreWaitInfo *out)
+static void convert_VkSemaphoreWaitInfo_win32_to_host(const VkSemaphoreWaitInfo32 *in, VkSemaphoreWaitInfo *out)
 {
     if (!in) return;

[PATCH v2 3/5] winevulkan: Build the struct extension list lazily.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/winevulkan/make_vulkan | 85 ++++++++++++++++++++-----------------
 1 file changed, 45 insertions(+), 40 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 68d0673719a..6beca732f4e 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -426,7 +426,7 @@ class VkDefine(object):
         self.value = value

@staticmethod
-    def from_xml(define):
+    def from_xml(registry, define):
         if not api_is_vulkan(define):
             return None

@@ -454,7 +454,7 @@ class VkEnum(object):
         self.aliased_by = []

@staticmethod
-    def from_alias(enum, alias):
+    def from_alias(registry, enum, alias):
         name = enum.attrib.get("name")
         aliasee = VkEnum(name, alias.bitwidth, alias=alias)

@@ -462,7 +462,7 @@ class VkEnum(object):
         return aliasee

@staticmethod
-    def from_xml(enum):
+    def from_xml(registry, enum):
         if not api_is_vulkan(enum):
             return None

@@ -621,7 +621,7 @@ class VkFunction(object):
             self.unwrap = Unwrap.HOST

@staticmethod
-    def from_alias(command, alias):
+    def from_alias(registry, command, alias):
         """ Create VkFunction from an alias command.

Args:
@@ -641,7 +641,7 @@ class VkFunction(object):
         return VkFunction(_type=func_type, name=func_name, params=params, alias=alias)

@staticmethod
-    def from_xml(command, types):
+    def from_xml(registry, command, types):
         if not api_is_vulkan(command):
             return None

@@ -651,7 +651,7 @@ class VkFunction(object):

params = []
         for param in command.findall("param"):
-            vk_param = VkParam.from_xml(param, types, params)
+            vk_param = VkParam.from_xml(registry, param, types, params)
             if vk_param:
                 params.append(vk_param)

@@ -997,7 +997,7 @@ class VkFunctionPointer(object):
         self.required = False

@staticmethod
-    def from_xml(funcpointer):
+    def from_xml(registry, funcpointer):
         if not api_is_vulkan(funcpointer):
             return None

@@ -1025,12 +1025,12 @@ class VkHandle(object):
         self.object_type = None

@staticmethod
-    def from_alias(handle, alias):
+    def from_alias(registry, handle, alias):
         name = handle.attrib.get("name")
         return VkHandle(name, alias.type, alias.parent, alias=alias)

@staticmethod
-    def from_xml(handle):
+    def from_xml(registry, handle):
         if not api_is_vulkan(handle):
             return None

@@ -1341,7 +1341,7 @@ class VkMember(VkVariable):
                 self.name, self.array_lens, self.dyn_array_len)

@staticmethod
-    def from_xml(member, returnedonly, parent):
+    def from_xml(registry, member, returnedonly, parent):
         """ Helper function for parsing a member tag within a struct or union. """

if not api_is_vulkan(member):
@@ -1584,7 +1584,7 @@ class VkParam(VkVariable):
         return "{0} {1} {2} {3} {4} {5}".format(self.const, self.type, self.pointer, self.name, self.array_lens, self.dyn_array_len)

@staticmethod
-    def from_xml(param, types, parent):
+    def from_xml(registry, param, types, parent):
         """ Helper function to create VkParam from xml. """

if not api_is_vulkan(param):
@@ -1880,7 +1880,8 @@ class VkParam(VkVariable):
 class VkStruct(Sequence):
     """ Class which represents the type union and struct. """

-    def __init__(self, name, members, returnedonly, structextends, alias=None, union=False):
+    def __init__(self, registry, name, members, returnedonly, structextends, alias=None, union=False):
+        self.registry = registry
         self.name = name
         self.members = members
         self.returnedonly = returnedonly
@@ -1889,7 +1890,7 @@ class VkStruct(Sequence):
         self.alias = alias
         self.union = union
         self.type_info = None # To be set later.
-        self.struct_extensions = []
+        self._extensions = None
         self.aliased_by = []
         self.order = 0

@@ -1900,15 +1901,15 @@ class VkStruct(Sequence):
         return len(self.members)

@staticmethod
-    def from_alias(struct, alias):
+    def from_alias(registry, struct, alias):
         name = struct.attrib.get("name")
-        aliasee = VkStruct(name, alias.members, alias.returnedonly, alias.structextends, alias=alias)
+        aliasee = VkStruct(registry, name, alias.members, alias.returnedonly, alias.structextends, alias=alias)

alias.add_aliased_by(aliasee)
         return aliasee

@staticmethod
-    def from_xml(struct):
+    def from_xml(registry, struct):
         if not api_is_vulkan(struct):
             return None

@@ -1934,9 +1935,9 @@ class VkStruct(Sequence):
         structextends = struct.attrib.get("structextends")
         structextends = structextends.split(",") if structextends else []

-        s = VkStruct(name, [], returnedonly, structextends, union=union)
+        s = VkStruct(registry, name, [], returnedonly, structextends, union=union)
         for member in struct.findall("member"):
-            vk_member = VkMember.from_xml(member, returnedonly, s)
+            vk_member = VkMember.from_xml(registry, member, returnedonly, s)
             if vk_member:
                 s.members.append(vk_member)

@@ -1956,6 +1957,21 @@ class VkStruct(Sequence):
                 structs[member.type].alias.set_order(self.order, structs)
             structs[member.type].set_order(self.order, structs)

+    @property
+    def struct_extensions(self):
+        if self._extensions is None:
+            self._extensions = []
+
+            def is_struct_extension(s):
+                return not s.alias and self.name in s.structextends
+
+            for type_info in self.registry.types.values():
+                struct = type_info["data"] if type_info["category"] == "struct" else None
+                if struct and is_struct_extension(struct):
+                    self._extensions.append(struct)
+
+        return self._extensions
+
     def definition(self, align=False, conv=False):
         """ Convert structure to textual definition.

@@ -3188,14 +3204,14 @@ class VkRegistry(object):
                 alias_commands.append(command)
                 continue

-            func = VkFunction.from_xml(command, self.types)
+            func = VkFunction.from_xml(self, command, self.types)
             if func:
                 funcs[func.name] = func

for command in alias_commands:
             alias_name = command.attrib.get("alias")
             alias = funcs[alias_name]
-            func = VkFunction.from_alias(command, alias)
+            func = VkFunction.from_alias(self, command, alias)
             if func:
                 funcs[func.name] = func

@@ -3235,7 +3251,7 @@ class VkRegistry(object):
             _type = enum.attrib.get("type")

if _type in ("enum", "bitmask"):
-                enum_obj = VkEnum.from_xml(enum)
+                enum_obj = VkEnum.from_xml(self, enum)
                 if enum_obj:
                     enums[name] = enum_obj
             else:
@@ -3522,7 +3538,7 @@ class VkRegistry(object):

if type_info["category"] == "basetype":
                 name = t.find("name").text
-                define = VkDefine.from_xml(t)
+                define = VkDefine.from_xml(self, t)
                 defines.append(define)
                 type_info["data"] = define

@@ -3545,7 +3561,7 @@ class VkRegistry(object):
                 type_info["data"] = bitmask

elif type_info["category"] == "define":
-                define = VkDefine.from_xml(t)
+                define = VkDefine.from_xml(self, t)
                 if define:
                     defines.append(define)
                     type_info["data"] = define
@@ -3565,7 +3581,7 @@ class VkRegistry(object):
                     type_info["data"] = None

elif type_info["category"] == "funcpointer":
-                funcpointer = VkFunctionPointer.from_xml(t)
+                funcpointer = VkFunctionPointer.from_xml(self, t)
                 if funcpointer:
                     funcpointers.append(funcpointer)
                     type_info["data"] = funcpointer
@@ -3573,7 +3589,7 @@ class VkRegistry(object):
                     continue

elif type_info["category"] == "handle":
-                handle = VkHandle.from_xml(t)
+                handle = VkHandle.from_xml(self, t)
                 if handle:
                     handles.append(handle)
                     type_info["data"] = handle
@@ -3585,7 +3601,7 @@ class VkRegistry(object):
                 # on unions. The types are very similar in parsing and
                 # generation anyway. The official Vulkan scripts use
                 # a similar kind of hack.
-                struct = VkStruct.from_xml(t)
+                struct = VkStruct.from_xml(self, t)
                 if struct:
                     structs.append(struct)
                     type_info["data"] = struct
@@ -3620,17 +3636,17 @@ class VkRegistry(object):
                 type_info["data"] = bitmask

if type_info["category"] == "enum":
-                enum = VkEnum.from_alias(t, self.types[alias]["data"])
+                enum = VkEnum.from_alias(self, t, self.types[alias]["data"])
                 type_info["data"] = enum
                 self.enums[enum.name] = enum

if type_info["category"] == "handle":
-                handle = VkHandle.from_alias(t, self.types[alias]["data"])
+                handle = VkHandle.from_alias(self, t, self.types[alias]["data"])
                 handles.append(handle)
                 type_info["data"] = handle

if type_info["category"] == "struct":
-                struct = VkStruct.from_alias(t, self.types[alias]["data"])
+                struct = VkStruct.from_alias(self, t, self.types[alias]["data"])
                 structs.append(struct)
                 type_info["data"] = struct

@@ -3645,17 +3661,6 @@ class VkRegistry(object):
         for struct in structs.values():
             struct.set_type_info(self.types)

-            # Alias structures have enum values equivalent to those of the
-            # structure which they are aliased against. we need to ignore alias
-            # structs when populating the struct extensions list, otherwise we
-            # will create duplicate case entries.
-            if struct.alias:
-                continue
-
-            for structextend in struct.structextends:
-                s = self.types[structextend]["data"]
-                s.struct_extensions.append(struct)
-
         for struct in structs.values():
             struct.set_order(0, structs)

[PATCH v2 4/5] winevulkan: Enumerate struct extensions with the registry structs.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/winevulkan/make_vulkan     |     7 +-
 dlls/winevulkan/vulkan_thunks.c | 17302 +++++++++++++++---------------
 2 files changed, 8654 insertions(+), 8655 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 6beca732f4e..4b7c553a44e 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -1965,10 +1965,9 @@ class VkStruct(Sequence):
             def is_struct_extension(s):
                 return not s.alias and self.name in s.structextends

-            for type_info in self.registry.types.values():
-                struct = type_info["data"] if type_info["category"] == "struct" else None
-                if struct and is_struct_extension(struct):
-                    self._extensions.append(struct)
+            structs = sorted(self.registry.structs, key=lambda s: s.name)
+            for struct in filter(is_struct_extension, structs):
+                self._extensions.append(struct)

return self._extensions

diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index a9d1616def4..3a3549f7dda 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -9698,27 +9698,39 @@ static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
         {
-            VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImportMemoryWin32HandleInfoKHR32 *in_ext = (const VkImportMemoryWin32HandleInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
+            VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkExportMemoryWin32HandleInfoKHR32 *in_ext = (const VkExportMemoryWin32HandleInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->handleType = in_ext->handleType;
-            out_ext->handle = in_ext->handle;
+            out_ext->pAttributes = UlongToPtr(in_ext->pAttributes);
+            out_ext->dwAccess = in_ext->dwAccess;
             out_ext->name = in_ext->name;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
         {
-            VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkExportMemoryWin32HandleInfoKHR32 *in_ext = (const VkExportMemoryWin32HandleInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
+            VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImportMemoryHostPointerInfoEXT32 *in_ext = (const VkImportMemoryHostPointerInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->pAttributes = UlongToPtr(in_ext->pAttributes);
-            out_ext->dwAccess = in_ext->dwAccess;
+            out_ext->handleType = in_ext->handleType;
+            out_ext->pHostPointer = UlongToPtr(in_ext->pHostPointer);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+        {
+            VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImportMemoryWin32HandleInfoKHR32 *in_ext = (const VkImportMemoryWin32HandleInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
+            out_ext->pNext = NULL;
+            out_ext->handleType = in_ext->handleType;
+            out_ext->handle = in_ext->handle;
             out_ext->name = in_ext->name;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -9748,25 +9760,13 @@ static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
-        {
-            VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImportMemoryHostPointerInfoEXT32 *in_ext = (const VkImportMemoryHostPointerInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->handleType = in_ext->handleType;
-            out_ext->pHostPointer = UlongToPtr(in_ext->pHostPointer);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM:
         {
-            VkMemoryPriorityAllocateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkMemoryPriorityAllocateInfoEXT32 *in_ext = (const VkMemoryPriorityAllocateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT;
+            VkMemoryDedicatedAllocateInfoTensorARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkMemoryDedicatedAllocateInfoTensorARM32 *in_ext = (const VkMemoryDedicatedAllocateInfoTensorARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM;
             out_ext->pNext = NULL;
-            out_ext->priority = in_ext->priority;
+            out_ext->tensor = in_ext->tensor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -9782,13 +9782,13 @@ static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM:
+        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
         {
-            VkMemoryDedicatedAllocateInfoTensorARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkMemoryDedicatedAllocateInfoTensorARM32 *in_ext = (const VkMemoryDedicatedAllocateInfoTensorARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM;
+            VkMemoryPriorityAllocateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkMemoryPriorityAllocateInfoEXT32 *in_ext = (const VkMemoryPriorityAllocateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->tensor = in_ext->tensor;
+            out_ext->priority = in_ext->priority;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -9862,6 +9862,19 @@ static void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct conversi
     {
         switch (in_header->sType)
         {
+        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
+        {
+            VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
+            out_ext->pNext = NULL;
+            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
+            out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
+            out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
         {
             VkCommandBufferInheritanceConditionalRenderingInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -9885,19 +9898,6 @@ static void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct conversi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
-        {
-            VkCommandBufferInheritanceViewportScissorInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkCommandBufferInheritanceViewportScissorInfoNV *in_ext = (const VkCommandBufferInheritanceViewportScissorInfoNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV;
-            out_ext->pNext = NULL;
-            out_ext->viewportScissor2D = in_ext->viewportScissor2D;
-            out_ext->viewportDepthCount = in_ext->viewportDepthCount;
-            out_ext->pViewportDepths = in_ext->pViewportDepths;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
         {
             VkCommandBufferInheritanceRenderingInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -9915,26 +9915,27 @@ static void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct conversi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
         {
-            VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
+            VkCommandBufferInheritanceViewportScissorInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkCommandBufferInheritanceViewportScissorInfoNV *in_ext = (const VkCommandBufferInheritanceViewportScissorInfoNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
-            out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
-            out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
+            out_ext->viewportScissor2D = in_ext->viewportScissor2D;
+            out_ext->viewportDepthCount = in_ext->viewportDepthCount;
+            out_ext->pViewportDepths = in_ext->pViewportDepths;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
+        case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
         {
-            VkTileMemoryBindInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkTileMemoryBindInfoQCOM *in_ext = (const VkTileMemoryBindInfoQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM;
+            VkRenderPassTileShadingCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRenderPassTileShadingCreateInfoQCOM *in_ext = (const VkRenderPassTileShadingCreateInfoQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM;
             out_ext->pNext = NULL;
-            out_ext->memory = vulkan_device_memory_from_handle(in_ext->memory)->host.device_memory;
+            out_ext->flags = in_ext->flags;
+            out_ext->tileApronSize = in_ext->tileApronSize;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -9965,14 +9966,13 @@ static void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct conversi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
         {
-            VkRenderPassTileShadingCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRenderPassTileShadingCreateInfoQCOM *in_ext = (const VkRenderPassTileShadingCreateInfoQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM;
+            VkTileMemoryBindInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkTileMemoryBindInfoQCOM *in_ext = (const VkTileMemoryBindInfoQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->tileApronSize = in_ext->tileApronSize;
+            out_ext->memory = vulkan_device_memory_from_handle(in_ext->memory)->host.device_memory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -10035,6 +10035,19 @@ static void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversi
     {
         switch (in_header->sType)
         {
+        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
+        {
+            VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
+            out_ext->pNext = NULL;
+            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
+            out_ext->pColorAttachmentSamples = UlongToPtr(in_ext->pColorAttachmentSamples);
+            out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
         {
             VkCommandBufferInheritanceConditionalRenderingInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -10058,19 +10071,6 @@ static void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
-        {
-            VkCommandBufferInheritanceViewportScissorInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkCommandBufferInheritanceViewportScissorInfoNV32 *in_ext = (const VkCommandBufferInheritanceViewportScissorInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV;
-            out_ext->pNext = NULL;
-            out_ext->viewportScissor2D = in_ext->viewportScissor2D;
-            out_ext->viewportDepthCount = in_ext->viewportDepthCount;
-            out_ext->pViewportDepths = UlongToPtr(in_ext->pViewportDepths);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
         {
             VkCommandBufferInheritanceRenderingInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -10088,26 +10088,27 @@ static void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
         {
-            VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
+            VkCommandBufferInheritanceViewportScissorInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkCommandBufferInheritanceViewportScissorInfoNV32 *in_ext = (const VkCommandBufferInheritanceViewportScissorInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
-            out_ext->pColorAttachmentSamples = UlongToPtr(in_ext->pColorAttachmentSamples);
-            out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
+            out_ext->viewportScissor2D = in_ext->viewportScissor2D;
+            out_ext->viewportDepthCount = in_ext->viewportDepthCount;
+            out_ext->pViewportDepths = UlongToPtr(in_ext->pViewportDepths);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
+        case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
         {
-            VkTileMemoryBindInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkTileMemoryBindInfoQCOM32 *in_ext = (const VkTileMemoryBindInfoQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM;
+            VkRenderPassTileShadingCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRenderPassTileShadingCreateInfoQCOM32 *in_ext = (const VkRenderPassTileShadingCreateInfoQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM;
             out_ext->pNext = NULL;
-            out_ext->memory = vulkan_device_memory_from_handle(in_ext->memory)->host.device_memory;
+            out_ext->flags = in_ext->flags;
+            out_ext->tileApronSize = in_ext->tileApronSize;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -10138,14 +10139,13 @@ static void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
         {
-            VkRenderPassTileShadingCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRenderPassTileShadingCreateInfoQCOM32 *in_ext = (const VkRenderPassTileShadingCreateInfoQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM;
+            VkTileMemoryBindInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkTileMemoryBindInfoQCOM32 *in_ext = (const VkTileMemoryBindInfoQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->tileApronSize = in_ext->tileApronSize;
+            out_ext->memory = vulkan_device_memory_from_handle(in_ext->memory)->host.device_memory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -11186,16 +11186,14 @@ static void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
         {
-            VkRenderPassSampleLocationsBeginInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRenderPassSampleLocationsBeginInfoEXT32 *in_ext = (const VkRenderPassSampleLocationsBeginInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT;
+            VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM;
             out_ext->pNext = NULL;
-            out_ext->attachmentInitialSampleLocationsCount = in_ext->attachmentInitialSampleLocationsCount;
-            out_ext->pAttachmentInitialSampleLocations = convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(ctx, (const VkAttachmentSampleLocationsEXT32 *)UlongToPtr(in_ext->pAttachmentInitialSampleLocations), in_ext->attachmentInitialSampleLocationsCount);
-            out_ext->postSubpassSampleLocationsCount = in_ext->postSubpassSampleLocationsCount;
-            out_ext->pPostSubpassSampleLocations = convert_VkSubpassSampleLocationsEXT_array_win32_to_host(ctx, (const VkSubpassSampleLocationsEXT32 *)UlongToPtr(in_ext->pPostSubpassSampleLocations), in_ext->postSubpassSampleLocationsCount);
+            out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount;
+            out_ext->pPerViewRenderAreas = UlongToPtr(in_ext->pPerViewRenderAreas);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -11212,25 +11210,16 @@ static void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
-        {
-            VkRenderPassTransformBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRenderPassTransformBeginInfoQCOM32 *in_ext = (const VkRenderPassTransformBeginInfoQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM;
-            out_ext->pNext = NULL;
-            out_ext->transform = in_ext->transform;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
         {
-            VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM;
+            VkRenderPassSampleLocationsBeginInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRenderPassSampleLocationsBeginInfoEXT32 *in_ext = (const VkRenderPassSampleLocationsBeginInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount;
-            out_ext->pPerViewRenderAreas = UlongToPtr(in_ext->pPerViewRenderAreas);
+            out_ext->attachmentInitialSampleLocationsCount = in_ext->attachmentInitialSampleLocationsCount;
+            out_ext->pAttachmentInitialSampleLocations = convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(ctx, (const VkAttachmentSampleLocationsEXT32 *)UlongToPtr(in_ext->pAttachmentInitialSampleLocations), in_ext->attachmentInitialSampleLocationsCount);
+            out_ext->postSubpassSampleLocationsCount = in_ext->postSubpassSampleLocationsCount;
+            out_ext->pPostSubpassSampleLocations = convert_VkSubpassSampleLocationsEXT_array_win32_to_host(ctx, (const VkSubpassSampleLocationsEXT32 *)UlongToPtr(in_ext->pPostSubpassSampleLocations), in_ext->postSubpassSampleLocationsCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -11247,6 +11236,17 @@ static void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
+        {
+            VkRenderPassTransformBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRenderPassTransformBeginInfoQCOM32 *in_ext = (const VkRenderPassTransformBeginInfoQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM;
+            out_ext->pNext = NULL;
+            out_ext->transform = in_ext->transform;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -11368,74 +11368,74 @@ static void convert_VkRenderingInfo_win32_to_host(struct conversion_context *ctx
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
         {
-            VkRenderingFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
+            VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM;
             out_ext->pNext = NULL;
-            out_ext->imageView = in_ext->imageView;
-            out_ext->imageLayout = in_ext->imageLayout;
-            out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
+            out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount;
+            out_ext->pPerViewRenderAreas = UlongToPtr(in_ext->pPerViewRenderAreas);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
+        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM:
         {
-            VkRenderingFragmentDensityMapAttachmentInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *in_ext = (const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT;
+            VkRenderPassStripeBeginInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRenderPassStripeBeginInfoARM32 *in_ext = (const VkRenderPassStripeBeginInfoARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM;
             out_ext->pNext = NULL;
-            out_ext->imageView = in_ext->imageView;
-            out_ext->imageLayout = in_ext->imageLayout;
+            out_ext->stripeInfoCount = in_ext->stripeInfoCount;
+            out_ext->pStripeInfos = convert_VkRenderPassStripeInfoARM_array_win32_to_host(ctx, (const VkRenderPassStripeInfoARM32 *)UlongToPtr(in_ext->pStripeInfos), in_ext->stripeInfoCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
+        case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
         {
-            VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM;
+            VkRenderPassTileShadingCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRenderPassTileShadingCreateInfoQCOM32 *in_ext = (const VkRenderPassTileShadingCreateInfoQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM;
             out_ext->pNext = NULL;
-            out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount;
-            out_ext->pPerViewRenderAreas = UlongToPtr(in_ext->pPerViewRenderAreas);
+            out_ext->flags = in_ext->flags;
+            out_ext->tileApronSize = in_ext->tileApronSize;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
+        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
         {
-            VkTileMemorySizeInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkTileMemorySizeInfoQCOM32 *in_ext = (const VkTileMemorySizeInfoQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM;
+            VkRenderingFragmentDensityMapAttachmentInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *in_ext = (const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->size = in_ext->size;
+            out_ext->imageView = in_ext->imageView;
+            out_ext->imageLayout = in_ext->imageLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM:
+        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
         {
-            VkRenderPassStripeBeginInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRenderPassStripeBeginInfoARM32 *in_ext = (const VkRenderPassStripeBeginInfoARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM;
+            VkRenderingFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->stripeInfoCount = in_ext->stripeInfoCount;
-            out_ext->pStripeInfos = convert_VkRenderPassStripeInfoARM_array_win32_to_host(ctx, (const VkRenderPassStripeInfoARM32 *)UlongToPtr(in_ext->pStripeInfos), in_ext->stripeInfoCount);
+            out_ext->imageView = in_ext->imageView;
+            out_ext->imageLayout = in_ext->imageLayout;
+            out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
         {
-            VkRenderPassTileShadingCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRenderPassTileShadingCreateInfoQCOM32 *in_ext = (const VkRenderPassTileShadingCreateInfoQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM;
+            VkTileMemorySizeInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkTileMemorySizeInfoQCOM32 *in_ext = (const VkTileMemorySizeInfoQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->tileApronSize = in_ext->tileApronSize;
+            out_ext->size = in_ext->size;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -11521,17 +11521,6 @@ static void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conversion_
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
-        {
-            VkVideoDecodeH264DpbSlotInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoDecodeH264DpbSlotInfoKHR32 *in_ext = (const VkVideoDecodeH264DpbSlotInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->pStdReferenceInfo = UlongToPtr(in_ext->pStdReferenceInfo);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
         {
             VkVideoDecodeAV1DpbSlotInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -11543,11 +11532,11 @@ static void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conversion_
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
         {
-            VkVideoEncodeH264DpbSlotInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeH264DpbSlotInfoKHR32 *in_ext = (const VkVideoEncodeH264DpbSlotInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR;
+            VkVideoDecodeH264DpbSlotInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoDecodeH264DpbSlotInfoKHR32 *in_ext = (const VkVideoDecodeH264DpbSlotInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR;
             out_ext->pNext = NULL;
             out_ext->pStdReferenceInfo = UlongToPtr(in_ext->pStdReferenceInfo);
             out_header->pNext = (void *)out_ext;
@@ -11565,6 +11554,17 @@ static void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conversion_
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR:
+        {
+            VkVideoEncodeH264DpbSlotInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeH264DpbSlotInfoKHR32 *in_ext = (const VkVideoEncodeH264DpbSlotInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR;
+            out_ext->pNext = NULL;
+            out_ext->pStdReferenceInfo = UlongToPtr(in_ext->pStdReferenceInfo);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR:
         {
             VkVideoReferenceIntraRefreshInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -11617,22 +11617,6 @@ static void convert_VkVideoEncodeRateControlLayerInfoKHR_win32_to_host(struct co
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
-        {
-            VkVideoEncodeH264RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeH264RateControlLayerInfoKHR32 *in_ext = (const VkVideoEncodeH264RateControlLayerInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->useMinQp = in_ext->useMinQp;
-            out_ext->minQp = in_ext->minQp;
-            out_ext->useMaxQp = in_ext->useMaxQp;
-            out_ext->maxQp = in_ext->maxQp;
-            out_ext->useMaxFrameSize = in_ext->useMaxFrameSize;
-            out_ext->maxFrameSize = in_ext->maxFrameSize;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
         {
             VkVideoEncodeAV1RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -11649,6 +11633,22 @@ static void convert_VkVideoEncodeRateControlLayerInfoKHR_win32_to_host(struct co
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
+        {
+            VkVideoEncodeH264RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeH264RateControlLayerInfoKHR32 *in_ext = (const VkVideoEncodeH264RateControlLayerInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR;
+            out_ext->pNext = NULL;
+            out_ext->useMinQp = in_ext->useMinQp;
+            out_ext->minQp = in_ext->minQp;
+            out_ext->useMaxQp = in_ext->useMaxQp;
+            out_ext->maxQp = in_ext->maxQp;
+            out_ext->useMaxFrameSize = in_ext->useMaxFrameSize;
+            out_ext->maxFrameSize = in_ext->maxFrameSize;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -11691,32 +11691,30 @@ static void convert_VkVideoBeginCodingInfoKHR_win32_to_host(struct conversion_co
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
         {
-            VkVideoEncodeRateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeRateControlInfoKHR32 *in_ext = (const VkVideoEncodeRateControlInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR;
+            VkVideoEncodeAV1GopRemainingFrameInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeAV1GopRemainingFrameInfoKHR32 *in_ext = (const VkVideoEncodeAV1GopRemainingFrameInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->rateControlMode = in_ext->rateControlMode;
-            out_ext->layerCount = in_ext->layerCount;
-            out_ext->pLayers = convert_VkVideoEncodeRateControlLayerInfoKHR_array_win32_to_host(ctx, (const VkVideoEncodeRateControlLayerInfoKHR32 *)UlongToPtr(in_ext->pLayers), in_ext->layerCount);
-            out_ext->virtualBufferSizeInMs = in_ext->virtualBufferSizeInMs;
-            out_ext->initialVirtualBufferSizeInMs = in_ext->initialVirtualBufferSizeInMs;
+            out_ext->useGopRemainingFrames = in_ext->useGopRemainingFrames;
+            out_ext->gopRemainingIntra = in_ext->gopRemainingIntra;
+            out_ext->gopRemainingPredictive = in_ext->gopRemainingPredictive;
+            out_ext->gopRemainingBipredictive = in_ext->gopRemainingBipredictive;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
         {
-            VkVideoEncodeH264RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeH264RateControlInfoKHR32 *in_ext = (const VkVideoEncodeH264RateControlInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR;
+            VkVideoEncodeAV1RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeAV1RateControlInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR;
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
             out_ext->gopFrameCount = in_ext->gopFrameCount;
-            out_ext->idrPeriod = in_ext->idrPeriod;
-            out_ext->consecutiveBFrameCount = in_ext->consecutiveBFrameCount;
+            out_ext->keyFramePeriod = in_ext->keyFramePeriod;
+            out_ext->consecutiveBipredictiveFrameCount = in_ext->consecutiveBipredictiveFrameCount;
             out_ext->temporalLayerCount = in_ext->temporalLayerCount;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -11736,31 +11734,33 @@ static void convert_VkVideoBeginCodingInfoKHR_win32_to_host(struct conversion_co
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR:
         {
-            VkVideoEncodeAV1RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeAV1RateControlInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR;
+            VkVideoEncodeH264RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeH264RateControlInfoKHR32 *in_ext = (const VkVideoEncodeH264RateControlInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR;
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
             out_ext->gopFrameCount = in_ext->gopFrameCount;
-            out_ext->keyFramePeriod = in_ext->keyFramePeriod;
-            out_ext->consecutiveBipredictiveFrameCount = in_ext->consecutiveBipredictiveFrameCount;
+            out_ext->idrPeriod = in_ext->idrPeriod;
+            out_ext->consecutiveBFrameCount = in_ext->consecutiveBFrameCount;
             out_ext->temporalLayerCount = in_ext->temporalLayerCount;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
         {
-            VkVideoEncodeAV1GopRemainingFrameInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeAV1GopRemainingFrameInfoKHR32 *in_ext = (const VkVideoEncodeAV1GopRemainingFrameInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR;
+            VkVideoEncodeRateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeRateControlInfoKHR32 *in_ext = (const VkVideoEncodeRateControlInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->useGopRemainingFrames = in_ext->useGopRemainingFrames;
-            out_ext->gopRemainingIntra = in_ext->gopRemainingIntra;
-            out_ext->gopRemainingPredictive = in_ext->gopRemainingPredictive;
-            out_ext->gopRemainingBipredictive = in_ext->gopRemainingBipredictive;
+            out_ext->flags = in_ext->flags;
+            out_ext->rateControlMode = in_ext->rateControlMode;
+            out_ext->layerCount = in_ext->layerCount;
+            out_ext->pLayers = convert_VkVideoEncodeRateControlLayerInfoKHR_array_win32_to_host(ctx, (const VkVideoEncodeRateControlLayerInfoKHR32 *)UlongToPtr(in_ext->pLayers), in_ext->layerCount);
+            out_ext->virtualBufferSizeInMs = in_ext->virtualBufferSizeInMs;
+            out_ext->initialVirtualBufferSizeInMs = in_ext->initialVirtualBufferSizeInMs;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -12356,29 +12356,17 @@ static void convert_VkVideoCodingControlInfoKHR_win32_to_host(struct conversion_
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
-        {
-            VkVideoEncodeQualityLevelInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeQualityLevelInfoKHR32 *in_ext = (const VkVideoEncodeQualityLevelInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->qualityLevel = in_ext->qualityLevel;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
         {
-            VkVideoEncodeRateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeRateControlInfoKHR32 *in_ext = (const VkVideoEncodeRateControlInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR;
+            VkVideoEncodeAV1RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeAV1RateControlInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR;
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
-            out_ext->rateControlMode = in_ext->rateControlMode;
-            out_ext->layerCount = in_ext->layerCount;
-            out_ext->pLayers = convert_VkVideoEncodeRateControlLayerInfoKHR_array_win32_to_host(ctx, (const VkVideoEncodeRateControlLayerInfoKHR32 *)UlongToPtr(in_ext->pLayers), in_ext->layerCount);
-            out_ext->virtualBufferSizeInMs = in_ext->virtualBufferSizeInMs;
-            out_ext->initialVirtualBufferSizeInMs = in_ext->initialVirtualBufferSizeInMs;
+            out_ext->gopFrameCount = in_ext->gopFrameCount;
+            out_ext->keyFramePeriod = in_ext->keyFramePeriod;
+            out_ext->consecutiveBipredictiveFrameCount = in_ext->consecutiveBipredictiveFrameCount;
+            out_ext->temporalLayerCount = in_ext->temporalLayerCount;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -12398,17 +12386,29 @@ static void convert_VkVideoCodingControlInfoKHR_win32_to_host(struct conversion_
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
         {
-            VkVideoEncodeAV1RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeAV1RateControlInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR;
+            VkVideoEncodeQualityLevelInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeQualityLevelInfoKHR32 *in_ext = (const VkVideoEncodeQualityLevelInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR;
+            out_ext->pNext = NULL;
+            out_ext->qualityLevel = in_ext->qualityLevel;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
+        {
+            VkVideoEncodeRateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeRateControlInfoKHR32 *in_ext = (const VkVideoEncodeRateControlInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR;
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
-            out_ext->gopFrameCount = in_ext->gopFrameCount;
-            out_ext->keyFramePeriod = in_ext->keyFramePeriod;
-            out_ext->consecutiveBipredictiveFrameCount = in_ext->consecutiveBipredictiveFrameCount;
-            out_ext->temporalLayerCount = in_ext->temporalLayerCount;
+            out_ext->rateControlMode = in_ext->rateControlMode;
+            out_ext->layerCount = in_ext->layerCount;
+            out_ext->pLayers = convert_VkVideoEncodeRateControlLayerInfoKHR_array_win32_to_host(ctx, (const VkVideoEncodeRateControlLayerInfoKHR32 *)UlongToPtr(in_ext->pLayers), in_ext->layerCount);
+            out_ext->virtualBufferSizeInMs = in_ext->virtualBufferSizeInMs;
+            out_ext->initialVirtualBufferSizeInMs = in_ext->initialVirtualBufferSizeInMs;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -12841,47 +12841,7 @@ static void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebugMarker
         FIXME("Unexpected pNext\n");
 }

-static void convert_StdVideoDecodeVP9PictureInfo_win32_to_host(const StdVideoDecodeVP9PictureInfo32 *in, StdVideoDecodeVP9PictureInfo *out)
-{
-    if (!in) return;
-
-    out->flags = in->flags;
-    out->profile = in->profile;
-    out->frame_type = in->frame_type;
-    out->frame_context_idx = in->frame_context_idx;
-    out->reset_frame_context = in->reset_frame_context;
-    out->refresh_frame_flags = in->refresh_frame_flags;
-    out->ref_frame_sign_bias_mask = in->ref_frame_sign_bias_mask;
-    out->interpolation_filter = in->interpolation_filter;
-    out->base_q_idx = in->base_q_idx;
-    out->delta_q_y_dc = in->delta_q_y_dc;
-    out->delta_q_uv_dc = in->delta_q_uv_dc;
-    out->delta_q_uv_ac = in->delta_q_uv_ac;
-    out->tile_cols_log2 = in->tile_cols_log2;
-    out->tile_rows_log2 = in->tile_rows_log2;
-    memcpy(out->reserved1, in->reserved1, 3 * sizeof(uint16_t));
-    out->pColorConfig = UlongToPtr(in->pColorConfig);
-    out->pLoopFilter = UlongToPtr(in->pLoopFilter);
-    out->pSegmentation = UlongToPtr(in->pSegmentation);
-}
-
-static const StdVideoDecodeVP9PictureInfo *convert_StdVideoDecodeVP9PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeVP9PictureInfo32 *in, uint32_t count)
-{
-    StdVideoDecodeVP9PictureInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_StdVideoDecodeVP9PictureInfo_win32_to_host(&in[i], &out[i]);
-    }
-
-    return out;
-}
-
-static void convert_StdVideoAV1TileInfo_win32_to_host(const StdVideoAV1TileInfo32 *in, StdVideoAV1TileInfo *out)
+static void convert_StdVideoAV1TileInfo_win32_to_host(const StdVideoAV1TileInfo32 *in, StdVideoAV1TileInfo *out)
 {
     if (!in) return;

@@ -12959,6 +12919,46 @@ static const StdVideoDecodeAV1PictureInfo *convert_StdVideoDecodeAV1PictureInfo_
     return out;
 }

+static void convert_StdVideoDecodeVP9PictureInfo_win32_to_host(const StdVideoDecodeVP9PictureInfo32 *in, StdVideoDecodeVP9PictureInfo *out)
+{
+    if (!in) return;
+
+    out->flags = in->flags;
+    out->profile = in->profile;
+    out->frame_type = in->frame_type;
+    out->frame_context_idx = in->frame_context_idx;
+    out->reset_frame_context = in->reset_frame_context;
+    out->refresh_frame_flags = in->refresh_frame_flags;
+    out->ref_frame_sign_bias_mask = in->ref_frame_sign_bias_mask;
+    out->interpolation_filter = in->interpolation_filter;
+    out->base_q_idx = in->base_q_idx;
+    out->delta_q_y_dc = in->delta_q_y_dc;
+    out->delta_q_uv_dc = in->delta_q_uv_dc;
+    out->delta_q_uv_ac = in->delta_q_uv_ac;
+    out->tile_cols_log2 = in->tile_cols_log2;
+    out->tile_rows_log2 = in->tile_rows_log2;
+    memcpy(out->reserved1, in->reserved1, 3 * sizeof(uint16_t));
+    out->pColorConfig = UlongToPtr(in->pColorConfig);
+    out->pLoopFilter = UlongToPtr(in->pLoopFilter);
+    out->pSegmentation = UlongToPtr(in->pSegmentation);
+}
+
+static const StdVideoDecodeVP9PictureInfo *convert_StdVideoDecodeVP9PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeVP9PictureInfo32 *in, uint32_t count)
+{
+    StdVideoDecodeVP9PictureInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_StdVideoDecodeVP9PictureInfo_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
 static void convert_VkVideoDecodeInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeInfoKHR32 *in, VkVideoDecodeInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
@@ -12981,15 +12981,18 @@ static void convert_VkVideoDecodeInfoKHR_win32_to_host(struct conversion_context
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
         {
-            VkVideoInlineQueryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoInlineQueryInfoKHR32 *in_ext = (const VkVideoInlineQueryInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR;
+            VkVideoDecodeAV1PictureInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoDecodeAV1PictureInfoKHR32 *in_ext = (const VkVideoDecodeAV1PictureInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->queryPool = in_ext->queryPool;
-            out_ext->firstQuery = in_ext->firstQuery;
-            out_ext->queryCount = in_ext->queryCount;
+            out_ext->pStdPictureInfo = convert_StdVideoDecodeAV1PictureInfo_array_win32_to_host(ctx, (const StdVideoDecodeAV1PictureInfo32 *)UlongToPtr(in_ext->pStdPictureInfo), 1);
+            memcpy(out_ext->referenceNameSlotIndices, in_ext->referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR * sizeof(int32_t));
+            out_ext->frameHeaderOffset = in_ext->frameHeaderOffset;
+            out_ext->tileCount = in_ext->tileCount;
+            out_ext->pTileOffsets = UlongToPtr(in_ext->pTileOffsets);
+            out_ext->pTileSizes = UlongToPtr(in_ext->pTileSizes);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13022,18 +13025,15 @@ static void convert_VkVideoDecodeInfoKHR_win32_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
         {
-            VkVideoDecodeAV1PictureInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoDecodeAV1PictureInfoKHR32 *in_ext = (const VkVideoDecodeAV1PictureInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR;
+            VkVideoInlineQueryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoInlineQueryInfoKHR32 *in_ext = (const VkVideoInlineQueryInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->pStdPictureInfo = convert_StdVideoDecodeAV1PictureInfo_array_win32_to_host(ctx, (const StdVideoDecodeAV1PictureInfo32 *)UlongToPtr(in_ext->pStdPictureInfo), 1);
-            memcpy(out_ext->referenceNameSlotIndices, in_ext->referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR * sizeof(int32_t));
-            out_ext->frameHeaderOffset = in_ext->frameHeaderOffset;
-            out_ext->tileCount = in_ext->tileCount;
-            out_ext->pTileOffsets = UlongToPtr(in_ext->pTileOffsets);
-            out_ext->pTileSizes = UlongToPtr(in_ext->pTileSizes);
+            out_ext->queryPool = in_ext->queryPool;
+            out_ext->firstQuery = in_ext->firstQuery;
+            out_ext->queryCount = in_ext->queryCount;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13093,6 +13093,55 @@ static void convert_VkDispatchTileInfoQCOM_win32_to_host(const VkDispatchTileInf
         FIXME("Unexpected pNext\n");
 }

+static void convert_StdVideoEncodeAV1PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, StdVideoEncodeAV1PictureInfo *out)
+{
+    if (!in) return;
+
+    out->flags = in->flags;
+    out->frame_type = in->frame_type;
+    out->frame_presentation_time = in->frame_presentation_time;
+    out->current_frame_id = in->current_frame_id;
+    out->order_hint = in->order_hint;
+    out->primary_ref_frame = in->primary_ref_frame;
+    out->refresh_frame_flags = in->refresh_frame_flags;
+    out->coded_denom = in->coded_denom;
+    out->render_width_minus_1 = in->render_width_minus_1;
+    out->render_height_minus_1 = in->render_height_minus_1;
+    out->interpolation_filter = in->interpolation_filter;
+    out->TxMode = in->TxMode;
+    out->delta_q_res = in->delta_q_res;
+    out->delta_lf_res = in->delta_lf_res;
+    memcpy(out->ref_order_hint, in->ref_order_hint, STD_VIDEO_AV1_NUM_REF_FRAMES * sizeof(uint8_t));
+    memcpy(out->ref_frame_idx, in->ref_frame_idx, STD_VIDEO_AV1_REFS_PER_FRAME * sizeof(int8_t));
+    memcpy(out->reserved1, in->reserved1, 3 * sizeof(uint8_t));
+    memcpy(out->delta_frame_id_minus_1, in->delta_frame_id_minus_1, STD_VIDEO_AV1_REFS_PER_FRAME * sizeof(uint32_t));
+    out->pTileInfo = convert_StdVideoAV1TileInfo_array_win32_to_host(ctx, (const StdVideoAV1TileInfo32 *)UlongToPtr(in->pTileInfo), 1);
+    out->pQuantization = UlongToPtr(in->pQuantization);
+    out->pSegmentation = UlongToPtr(in->pSegmentation);
+    out->pLoopFilter = UlongToPtr(in->pLoopFilter);
+    out->pCDEF = UlongToPtr(in->pCDEF);
+    out->pLoopRestoration = UlongToPtr(in->pLoopRestoration);
+    out->pGlobalMotion = UlongToPtr(in->pGlobalMotion);
+    out->pExtensionHeader = UlongToPtr(in->pExtensionHeader);
+    out->pBufferRemovalTimes = UlongToPtr(in->pBufferRemovalTimes);
+}
+
+static const StdVideoEncodeAV1PictureInfo *convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, uint32_t count)
+{
+    StdVideoEncodeAV1PictureInfo *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_StdVideoEncodeAV1PictureInfo_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
 static void convert_StdVideoEncodeH264SliceHeader_win32_to_host(const StdVideoEncodeH264SliceHeader32 *in, StdVideoEncodeH264SliceHeader *out)
 {
     if (!in) return;
@@ -13219,55 +13268,6 @@ static const StdVideoEncodeH264PictureInfo *convert_StdVideoEncodeH264PictureInf
     return out;
 }

-static void convert_StdVideoEncodeAV1PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, StdVideoEncodeAV1PictureInfo *out)
-{
-    if (!in) return;
-
-    out->flags = in->flags;
-    out->frame_type = in->frame_type;
-    out->frame_presentation_time = in->frame_presentation_time;
-    out->current_frame_id = in->current_frame_id;
-    out->order_hint = in->order_hint;
-    out->primary_ref_frame = in->primary_ref_frame;
-    out->refresh_frame_flags = in->refresh_frame_flags;
-    out->coded_denom = in->coded_denom;
-    out->render_width_minus_1 = in->render_width_minus_1;
-    out->render_height_minus_1 = in->render_height_minus_1;
-    out->interpolation_filter = in->interpolation_filter;
-    out->TxMode = in->TxMode;
-    out->delta_q_res = in->delta_q_res;
-    out->delta_lf_res = in->delta_lf_res;
-    memcpy(out->ref_order_hint, in->ref_order_hint, STD_VIDEO_AV1_NUM_REF_FRAMES * sizeof(uint8_t));
-    memcpy(out->ref_frame_idx, in->ref_frame_idx, STD_VIDEO_AV1_REFS_PER_FRAME * sizeof(int8_t));
-    memcpy(out->reserved1, in->reserved1, 3 * sizeof(uint8_t));
-    memcpy(out->delta_frame_id_minus_1, in->delta_frame_id_minus_1, STD_VIDEO_AV1_REFS_PER_FRAME * sizeof(uint32_t));
-    out->pTileInfo = convert_StdVideoAV1TileInfo_array_win32_to_host(ctx, (const StdVideoAV1TileInfo32 *)UlongToPtr(in->pTileInfo), 1);
-    out->pQuantization = UlongToPtr(in->pQuantization);
-    out->pSegmentation = UlongToPtr(in->pSegmentation);
-    out->pLoopFilter = UlongToPtr(in->pLoopFilter);
-    out->pCDEF = UlongToPtr(in->pCDEF);
-    out->pLoopRestoration = UlongToPtr(in->pLoopRestoration);
-    out->pGlobalMotion = UlongToPtr(in->pGlobalMotion);
-    out->pExtensionHeader = UlongToPtr(in->pExtensionHeader);
-    out->pBufferRemovalTimes = UlongToPtr(in->pBufferRemovalTimes);
-}
-
-static const StdVideoEncodeAV1PictureInfo *convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, uint32_t count)
-{
-    StdVideoEncodeAV1PictureInfo *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_StdVideoEncodeAV1PictureInfo_win32_to_host(ctx, &in[i], &out[i]);
-    }
-
-    return out;
-}
-
 static void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeInfoKHR32 *in, VkVideoEncodeInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
@@ -13291,27 +13291,19 @@ static void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_context
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
-        {
-            VkVideoInlineQueryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoInlineQueryInfoKHR32 *in_ext = (const VkVideoInlineQueryInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->queryPool = in_ext->queryPool;
-            out_ext->firstQuery = in_ext->firstQuery;
-            out_ext->queryCount = in_ext->queryCount;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
         {
-            VkVideoEncodeQuantizationMapInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeQuantizationMapInfoKHR32 *in_ext = (const VkVideoEncodeQuantizationMapInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR;
+            VkVideoEncodeAV1PictureInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeAV1PictureInfoKHR32 *in_ext = (const VkVideoEncodeAV1PictureInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->quantizationMap = in_ext->quantizationMap;
-            out_ext->quantizationMapExtent = in_ext->quantizationMapExtent;
+            out_ext->predictionMode = in_ext->predictionMode;
+            out_ext->rateControlGroup = in_ext->rateControlGroup;
+            out_ext->constantQIndex = in_ext->constantQIndex;
+            out_ext->pStdPictureInfo = convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(ctx, (const StdVideoEncodeAV1PictureInfo32 *)UlongToPtr(in_ext->pStdPictureInfo), 1);
+            memcpy(out_ext->referenceNameSlotIndices, in_ext->referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR * sizeof(int32_t));
+            out_ext->primaryReferenceCdfOnly = in_ext->primaryReferenceCdfOnly;
+            out_ext->generateObuExtensionHeader = in_ext->generateObuExtensionHeader;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13330,23 +13322,6 @@ static void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
-        {
-            VkVideoEncodeAV1PictureInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeAV1PictureInfoKHR32 *in_ext = (const VkVideoEncodeAV1PictureInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->predictionMode = in_ext->predictionMode;
-            out_ext->rateControlGroup = in_ext->rateControlGroup;
-            out_ext->constantQIndex = in_ext->constantQIndex;
-            out_ext->pStdPictureInfo = convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(ctx, (const StdVideoEncodeAV1PictureInfo32 *)UlongToPtr(in_ext->pStdPictureInfo), 1);
-            memcpy(out_ext->referenceNameSlotIndices, in_ext->referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR * sizeof(int32_t));
-            out_ext->primaryReferenceCdfOnly = in_ext->primaryReferenceCdfOnly;
-            out_ext->generateObuExtensionHeader = in_ext->generateObuExtensionHeader;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR:
         {
             VkVideoEncodeIntraRefreshInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -13359,13 +13334,38 @@ static void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        default:
-            FIXME("Unhandled sType %u.\n", in_header->sType);
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
+        {
+            VkVideoEncodeQuantizationMapInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeQuantizationMapInfoKHR32 *in_ext = (const VkVideoEncodeQuantizationMapInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR;
+            out_ext->pNext = NULL;
+            out_ext->quantizationMap = in_ext->quantizationMap;
+            out_ext->quantizationMapExtent = in_ext->quantizationMapExtent;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
             break;
         }
-    }
-}
-
+        case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
+        {
+            VkVideoInlineQueryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoInlineQueryInfoKHR32 *in_ext = (const VkVideoInlineQueryInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR;
+            out_ext->pNext = NULL;
+            out_ext->queryPool = in_ext->queryPool;
+            out_ext->firstQuery = in_ext->firstQuery;
+            out_ext->queryCount = in_ext->queryCount;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        default:
+            FIXME("Unhandled sType %u.\n", in_header->sType);
+            break;
+        }
+    }
+}
+
 static void convert_VkPerTileEndInfoQCOM_win32_to_host(const VkPerTileEndInfoQCOM32 *in, VkPerTileEndInfoQCOM *out)
 {
     if (!in) return;
@@ -13706,6 +13706,17 @@ static void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_context
     {
         switch (in_header->sType)
         {
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
+        {
+            VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
+            out_ext->pNext = NULL;
+            out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
         {
             VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -13720,17 +13731,6 @@ static void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
-        {
-            VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
-            out_ext->pNext = NULL;
-            out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -13807,25 +13807,25 @@ static void convert_VkBufferMemoryBarrier2_win32_to_host(struct conversion_conte
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
         {
-            VkMemoryBarrierAccessFlags3KHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkMemoryBarrierAccessFlags3KHR32 *in_ext = (const VkMemoryBarrierAccessFlags3KHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR;
+            VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
             out_ext->pNext = NULL;
-            out_ext->srcAccessMask3 = in_ext->srcAccessMask3;
-            out_ext->dstAccessMask3 = in_ext->dstAccessMask3;
+            out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
         {
-            VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
+            VkMemoryBarrierAccessFlags3KHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkMemoryBarrierAccessFlags3KHR32 *in_ext = (const VkMemoryBarrierAccessFlags3KHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR;
             out_ext->pNext = NULL;
-            out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
+            out_ext->srcAccessMask3 = in_ext->srcAccessMask3;
+            out_ext->dstAccessMask3 = in_ext->dstAccessMask3;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13877,16 +13877,13 @@ static void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion_contex
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
         {
-            VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT;
+            VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
             out_ext->pNext = NULL;
-            out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
-            out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
-            out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
-            out_ext->pSampleLocations = UlongToPtr(in_ext->pSampleLocations);
+            out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13903,13 +13900,16 @@ static void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
+        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
         {
-            VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
+            VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
+            out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
+            out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
+            out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
+            out_ext->pSampleLocations = UlongToPtr(in_ext->pSampleLocations);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13991,6 +13991,18 @@ static void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ct
     {
         switch (in_header->sType)
         {
+        case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM:
+        {
+            VkTensorDependencyInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkTensorDependencyInfoARM32 *in_ext = (const VkTensorDependencyInfoARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM;
+            out_ext->pNext = NULL;
+            out_ext->tensorMemoryBarrierCount = in_ext->tensorMemoryBarrierCount;
+            out_ext->pTensorMemoryBarriers = convert_VkTensorMemoryBarrierARM_array_win32_to_host(ctx, (const VkTensorMemoryBarrierARM32 *)UlongToPtr(in_ext->pTensorMemoryBarriers), 1);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM:
         {
             VkTensorMemoryBarrierARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -14008,18 +14020,6 @@ static void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ct
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM:
-        {
-            VkTensorDependencyInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkTensorDependencyInfoARM32 *in_ext = (const VkTensorDependencyInfoARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM;
-            out_ext->pNext = NULL;
-            out_ext->tensorMemoryBarrierCount = in_ext->tensorMemoryBarrierCount;
-            out_ext->pTensorMemoryBarriers = convert_VkTensorMemoryBarrierARM_array_win32_to_host(ctx, (const VkTensorMemoryBarrierARM32 *)UlongToPtr(in_ext->pTensorMemoryBarriers), 1);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -14140,18 +14140,6 @@ static void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
-        {
-            VkWriteDescriptorSetInlineUniformBlock *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkWriteDescriptorSetInlineUniformBlock32 *in_ext = (const VkWriteDescriptorSetInlineUniformBlock32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
-            out_ext->pNext = NULL;
-            out_ext->dataSize = in_ext->dataSize;
-            out_ext->pData = UlongToPtr(in_ext->pData);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
         {
             VkWriteDescriptorSetAccelerationStructureKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -14176,6 +14164,18 @@ static void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
+        {
+            VkWriteDescriptorSetInlineUniformBlock *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkWriteDescriptorSetInlineUniformBlock32 *in_ext = (const VkWriteDescriptorSetInlineUniformBlock32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
+            out_ext->pNext = NULL;
+            out_ext->dataSize = in_ext->dataSize;
+            out_ext->pData = UlongToPtr(in_ext->pData);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV:
         {
             VkWriteDescriptorSetPartitionedAccelerationStructureNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -14747,17 +14747,6 @@ static void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct co
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
-        {
-            VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
         {
             VkAccelerationStructureMotionInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -14770,6 +14759,17 @@ static void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct co
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
+        {
+            VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -14829,13 +14829,14 @@ static void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion_contex
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
         {
-            VkVideoDecodeUsageInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoDecodeUsageInfoKHR32 *in_ext = (const VkVideoDecodeUsageInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR;
+            VkVideoDecodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoDecodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoDecodeAV1ProfileInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->videoUsageHints = in_ext->videoUsageHints;
+            out_ext->stdProfile = in_ext->stdProfile;
+            out_ext->filmGrainSupport = in_ext->filmGrainSupport;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -14852,38 +14853,35 @@ static void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
         {
-            VkVideoDecodeVP9ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoDecodeVP9ProfileInfoKHR32 *in_ext = (const VkVideoDecodeVP9ProfileInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR;
+            VkVideoDecodeUsageInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoDecodeUsageInfoKHR32 *in_ext = (const VkVideoDecodeUsageInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->stdProfile = in_ext->stdProfile;
+            out_ext->videoUsageHints = in_ext->videoUsageHints;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
         {
-            VkVideoDecodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoDecodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoDecodeAV1ProfileInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR;
+            VkVideoDecodeVP9ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoDecodeVP9ProfileInfoKHR32 *in_ext = (const VkVideoDecodeVP9ProfileInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR;
             out_ext->pNext = NULL;
             out_ext->stdProfile = in_ext->stdProfile;
-            out_ext->filmGrainSupport = in_ext->filmGrainSupport;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
         {
-            VkVideoEncodeUsageInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeUsageInfoKHR32 *in_ext = (const VkVideoEncodeUsageInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR;
+            VkVideoEncodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoEncodeAV1ProfileInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->videoUsageHints = in_ext->videoUsageHints;
-            out_ext->videoContentHints = in_ext->videoContentHints;
-            out_ext->tuningMode = in_ext->tuningMode;
+            out_ext->stdProfile = in_ext->stdProfile;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -14899,13 +14897,15 @@ static void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
         {
-            VkVideoEncodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoEncodeAV1ProfileInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR;
+            VkVideoEncodeUsageInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeUsageInfoKHR32 *in_ext = (const VkVideoEncodeUsageInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->stdProfile = in_ext->stdProfile;
+            out_ext->videoUsageHints = in_ext->videoUsageHints;
+            out_ext->videoContentHints = in_ext->videoContentHints;
+            out_ext->tuningMode = in_ext->tuningMode;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -14953,6 +14953,28 @@ static void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *
     {
         switch (in_header->sType)
         {
+        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
+        {
+            VkBufferDeviceAddressCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkBufferDeviceAddressCreateInfoEXT32 *in_ext = (const VkBufferDeviceAddressCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->deviceAddress = in_ext->deviceAddress;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
+        {
+            VkBufferOpaqueCaptureAddressCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkBufferOpaqueCaptureAddressCreateInfo32 *in_ext = (const VkBufferOpaqueCaptureAddressCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
+            out_ext->pNext = NULL;
+            out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO:
         {
             VkBufferUsageFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -14986,33 +15008,22 @@ static void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
         {
-            VkBufferOpaqueCaptureAddressCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkBufferOpaqueCaptureAddressCreateInfo32 *in_ext = (const VkBufferOpaqueCaptureAddressCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
+            VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
+            out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
         {
-            VkBufferDeviceAddressCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkBufferDeviceAddressCreateInfoEXT32 *in_ext = (const VkBufferDeviceAddressCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->deviceAddress = in_ext->deviceAddress;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
-        {
-            VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoProfileListInfoKHR32 *in_ext = (const VkVideoProfileListInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
+            VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoProfileListInfoKHR32 *in_ext = (const VkVideoProfileListInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
             out_ext->pNext = NULL;
             out_ext->profileCount = in_ext->profileCount;
             out_ext->pProfiles = convert_VkVideoProfileInfoKHR_array_win32_to_host(ctx, (const VkVideoProfileInfoKHR32 *)UlongToPtr(in_ext->pProfiles), in_ext->profileCount);
@@ -15020,17 +15031,6 @@ static void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
-        {
-            VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -15130,39 +15130,41 @@ static void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct convers
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
         {
-            VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkShaderModuleCreateInfo *in_ext = (const VkShaderModuleCreateInfo *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+            VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDebugUtilsObjectNameInfoEXT *in_ext = (const VkDebugUtilsObjectNameInfoEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->codeSize = in_ext->codeSize;
-            out_ext->pCode = in_ext->pCode;
+            out_ext->objectType = in_ext->objectType;
+            out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
+            out_ext->pObjectName = in_ext->pObjectName;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
         {
-            VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkShaderModuleValidationCacheCreateInfoEXT *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
+            VkPipelineRobustnessCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRobustnessCreateInfo *in_ext = (const VkPipelineRobustnessCreateInfo *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->validationCache = in_ext->validationCache;
+            out_ext->storageBuffers = in_ext->storageBuffers;
+            out_ext->uniformBuffers = in_ext->uniformBuffers;
+            out_ext->vertexInputs = in_ext->vertexInputs;
+            out_ext->images = in_ext->images;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
         {
-            VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDebugUtilsObjectNameInfoEXT *in_ext = (const VkDebugUtilsObjectNameInfoEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
+            VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->objectType = in_ext->objectType;
-            out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
-            out_ext->pObjectName = in_ext->pObjectName;
+            out_ext->identifierSize = in_ext->identifierSize;
+            out_ext->pIdentifier = in_ext->pIdentifier;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -15178,28 +15180,26 @@ static void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct convers
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
         {
-            VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
+            VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkShaderModuleCreateInfo *in_ext = (const VkShaderModuleCreateInfo *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->identifierSize = in_ext->identifierSize;
-            out_ext->pIdentifier = in_ext->pIdentifier;
+            out_ext->flags = in_ext->flags;
+            out_ext->codeSize = in_ext->codeSize;
+            out_ext->pCode = in_ext->pCode;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
         {
-            VkPipelineRobustnessCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRobustnessCreateInfo *in_ext = (const VkPipelineRobustnessCreateInfo *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO;
+            VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkShaderModuleValidationCacheCreateInfoEXT *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->storageBuffers = in_ext->storageBuffers;
-            out_ext->uniformBuffers = in_ext->uniformBuffers;
-            out_ext->vertexInputs = in_ext->vertexInputs;
-            out_ext->images = in_ext->images;
+            out_ext->validationCache = in_ext->validationCache;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -15315,39 +15315,41 @@ static void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct convers
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
         {
-            VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkShaderModuleCreateInfo32 *in_ext = (const VkShaderModuleCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+            VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDebugUtilsObjectNameInfoEXT32 *in_ext = (const VkDebugUtilsObjectNameInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->codeSize = in_ext->codeSize;
-            out_ext->pCode = UlongToPtr(in_ext->pCode);
+            out_ext->objectType = in_ext->objectType;
+            out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
+            out_ext->pObjectName = UlongToPtr(in_ext->pObjectName);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
         {
-            VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
+            VkPipelineRobustnessCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRobustnessCreateInfo32 *in_ext = (const VkPipelineRobustnessCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->validationCache = in_ext->validationCache;
+            out_ext->storageBuffers = in_ext->storageBuffers;
+            out_ext->uniformBuffers = in_ext->uniformBuffers;
+            out_ext->vertexInputs = in_ext->vertexInputs;
+            out_ext->images = in_ext->images;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
         {
-            VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDebugUtilsObjectNameInfoEXT32 *in_ext = (const VkDebugUtilsObjectNameInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
+            VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->objectType = in_ext->objectType;
-            out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
-            out_ext->pObjectName = UlongToPtr(in_ext->pObjectName);
+            out_ext->identifierSize = in_ext->identifierSize;
+            out_ext->pIdentifier = UlongToPtr(in_ext->pIdentifier);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -15363,28 +15365,26 @@ static void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct convers
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
         {
-            VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
+            VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkShaderModuleCreateInfo32 *in_ext = (const VkShaderModuleCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->identifierSize = in_ext->identifierSize;
-            out_ext->pIdentifier = UlongToPtr(in_ext->pIdentifier);
+            out_ext->flags = in_ext->flags;
+            out_ext->codeSize = in_ext->codeSize;
+            out_ext->pCode = UlongToPtr(in_ext->pCode);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
         {
-            VkPipelineRobustnessCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRobustnessCreateInfo32 *in_ext = (const VkPipelineRobustnessCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO;
+            VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->storageBuffers = in_ext->storageBuffers;
-            out_ext->uniformBuffers = in_ext->uniformBuffers;
-            out_ext->vertexInputs = in_ext->vertexInputs;
-            out_ext->images = in_ext->images;
+            out_ext->validationCache = in_ext->validationCache;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -15438,17 +15438,6 @@ static void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
-        {
-            VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCreateFlags2CreateInfo32 *in_ext = (const VkPipelineCreateFlags2CreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
-            out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
         {
             VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -15461,38 +15450,37 @@ static void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
         {
-            VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
+            VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
             out_ext->pNext = NULL;
-            out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
-            out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
-            out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
+            out_ext->compilerControlFlags = in_ext->compilerControlFlags;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
         {
-            VkSubpassShadingPipelineCreateInfoHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkSubpassShadingPipelineCreateInfoHUAWEI32 *in_ext = (const VkSubpassShadingPipelineCreateInfoHUAWEI32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI;
+            VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCreateFlags2CreateInfo32 *in_ext = (const VkPipelineCreateFlags2CreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->renderPass = in_ext->renderPass;
-            out_ext->subpass = in_ext->subpass;
+            out_ext->flags = in_ext->flags;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
         {
-            VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
+            VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->compilerControlFlags = in_ext->compilerControlFlags;
+            out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
+            out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
+            out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -15511,6 +15499,18 @@ static void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
+        {
+            VkSubpassShadingPipelineCreateInfoHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkSubpassShadingPipelineCreateInfoHUAWEI32 *in_ext = (const VkSubpassShadingPipelineCreateInfoHUAWEI32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI;
+            out_ext->pNext = NULL;
+            out_ext->renderPass = in_ext->renderPass;
+            out_ext->subpass = in_ext->subpass;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -15724,6 +15724,19 @@ static void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct conversi
     {
         switch (in_header->sType)
         {
+        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM:
+        {
+            VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *in_ext = (const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM;
+            out_ext->pNext = NULL;
+            out_ext->dimension = in_ext->dimension;
+            out_ext->zeroCount = in_ext->zeroCount;
+            out_ext->groupSize = in_ext->groupSize;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM:
         {
             VkTensorDescriptionARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -15740,19 +15753,6 @@ static void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct conversi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM:
-        {
-            VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *in_ext = (const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM;
-            out_ext->pNext = NULL;
-            out_ext->dimension = in_ext->dimension;
-            out_ext->zeroCount = in_ext->zeroCount;
-            out_ext->groupSize = in_ext->groupSize;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -15794,19 +15794,6 @@ static void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conver
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
-        {
-            VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
-            out_ext->pNext = NULL;
-            out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
-            out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
-            out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM:
         {
             VkDataGraphPipelineCompilerControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -15818,22 +15805,7 @@ static void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conver
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM:
-        {
-            VkDataGraphPipelineShaderModuleCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDataGraphPipelineShaderModuleCreateInfoARM32 *in_ext = (const VkDataGraphPipelineShaderModuleCreateInfoARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM;
-            out_ext->pNext = NULL;
-            out_ext->module = in_ext->module;
-            out_ext->pName = UlongToPtr(in_ext->pName);
-            out_ext->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, (const VkSpecializationInfo32 *)UlongToPtr(in_ext->pSpecializationInfo), 1);
-            out_ext->constantCount = in_ext->constantCount;
-            out_ext->pConstants = convert_VkDataGraphPipelineConstantARM_array_win32_to_host(ctx, (const VkDataGraphPipelineConstantARM32 *)UlongToPtr(in_ext->pConstants), in_ext->constantCount);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM:
+        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM:
         {
             VkDataGraphPipelineIdentifierCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
             const VkDataGraphPipelineIdentifierCreateInfoARM32 *in_ext = (const VkDataGraphPipelineIdentifierCreateInfoARM32 *)in_header;
@@ -15845,6 +15817,21 @@ static void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conver
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM:
+        {
+            VkDataGraphPipelineShaderModuleCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDataGraphPipelineShaderModuleCreateInfoARM32 *in_ext = (const VkDataGraphPipelineShaderModuleCreateInfoARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM;
+            out_ext->pNext = NULL;
+            out_ext->module = in_ext->module;
+            out_ext->pName = UlongToPtr(in_ext->pName);
+            out_ext->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, (const VkSpecializationInfo32 *)UlongToPtr(in_ext->pSpecializationInfo), 1);
+            out_ext->constantCount = in_ext->constantCount;
+            out_ext->pConstants = convert_VkDataGraphPipelineConstantARM_array_win32_to_host(ctx, (const VkDataGraphPipelineConstantARM32 *)UlongToPtr(in_ext->pConstants), in_ext->constantCount);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM:
         {
             VkDataGraphProcessingEngineCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -15857,6 +15844,19 @@ static void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conver
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+        {
+            VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
+            out_ext->pNext = NULL;
+            out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
+            out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
+            out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -15892,6 +15892,15 @@ static void convert_VkDataGraphPipelineCreateInfoARM_host_to_win32(const VkDataG
     {
         switch (in_header->sType)
         {
+        case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM:
+        {
+            VkDataGraphProcessingEngineCreateInfoARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM);
+            const VkDataGraphProcessingEngineCreateInfoARM *in_ext = (const VkDataGraphProcessingEngineCreateInfoARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM;
+            out_ext->pProcessingEngines = PtrToUlong(in_ext->pProcessingEngines);
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
         {
             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
@@ -15902,15 +15911,6 @@ static void convert_VkDataGraphPipelineCreateInfoARM_host_to_win32(const VkDataG
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM:
-        {
-            VkDataGraphProcessingEngineCreateInfoARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM);
-            const VkDataGraphProcessingEngineCreateInfoARM *in_ext = (const VkDataGraphProcessingEngineCreateInfoARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM;
-            out_ext->pProcessingEngines = PtrToUlong(in_ext->pProcessingEngines);
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             break;
         }
@@ -15999,6 +15999,18 @@ static void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conversion_c
     {
         switch (in_header->sType)
         {
+        case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM:
+        {
+            VkDataGraphProcessingEngineCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDataGraphProcessingEngineCreateInfoARM32 *in_ext = (const VkDataGraphProcessingEngineCreateInfoARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM;
+            out_ext->pNext = NULL;
+            out_ext->processingEngineCount = in_ext->processingEngineCount;
+            out_ext->pProcessingEngines = UlongToPtr(in_ext->pProcessingEngines);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
         {
             VkDescriptorPoolInlineUniformBlockCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -16022,18 +16034,6 @@ static void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conversion_c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM:
-        {
-            VkDataGraphProcessingEngineCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDataGraphProcessingEngineCreateInfoARM32 *in_ext = (const VkDataGraphProcessingEngineCreateInfoARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM;
-            out_ext->pNext = NULL;
-            out_ext->processingEngineCount = in_ext->processingEngineCount;
-            out_ext->pProcessingEngines = UlongToPtr(in_ext->pProcessingEngines);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -16205,198 +16205,189 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *
         {
         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
+            VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDeviceDiagnosticsConfigCreateInfoNV *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
+            out_ext->flags = in_ext->flags;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
+            VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDeviceGroupDeviceCreateInfo *in_ext = (const VkDeviceGroupDeviceCreateInfo *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute;
-            out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines;
-            out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay;
+            out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
+            out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win64_to_host(ctx, in_ext->pPhysicalDevices, in_ext->physicalDeviceCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
         {
-            VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDevicePrivateDataCreateInfo *in_ext = (const VkDevicePrivateDataCreateInfo *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
+            VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDeviceMemoryOverallocationCreateInfoAMD *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
             out_ext->pNext = NULL;
-            out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
+            out_ext->overallocationBehavior = in_ext->overallocationBehavior;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
+        case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
         {
-            VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
+            VkDevicePipelineBinaryInternalCacheControlKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDevicePipelineBinaryInternalCacheControlKHR *in_ext = (const VkDevicePipelineBinaryInternalCacheControlKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR;
             out_ext->pNext = NULL;
-            out_ext->privateData = in_ext->privateData;
+            out_ext->disableInternalCache = in_ext->disableInternalCache;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
         {
-            VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV;
+            VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDevicePrivateDataCreateInfo *in_ext = (const VkDevicePrivateDataCreateInfo *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure;
+            out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
         {
-            VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFeatures2 *in_ext = (const VkPhysicalDeviceFeatures2 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+            VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDeviceQueueShaderCoreControlCreateInfoARM *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM;
             out_ext->pNext = NULL;
-            out_ext->features = in_ext->features;
+            out_ext->shaderCoreCount = in_ext->shaderCoreCount;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR:
         {
-            VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
+            VkPerformanceQueryReservationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPerformanceQueryReservationInfoKHR *in_ext = (const VkPerformanceQueryReservationInfoKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
-            out_ext->variablePointers = in_ext->variablePointers;
+            out_ext->maxPerformanceQueriesPerPool = in_ext->maxPerformanceQueriesPerPool;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
         {
-            VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
+            VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->multiview = in_ext->multiview;
-            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
-            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
+            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
+            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
+            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
+            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
         {
-            VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDeviceGroupDeviceCreateInfo *in_ext = (const VkDeviceGroupDeviceCreateInfo *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
+            VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
-            out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win64_to_host(ctx, in_ext->pPhysicalDevices, in_ext->physicalDeviceCount);
+            out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
+            out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
         {
-            VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
+            VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->presentId = in_ext->presentId;
+            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
+            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
+            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
         {
-            VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentId2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR;
+            VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->presentId2 = in_ext->presentId2;
+            out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
         {
-            VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
+            VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->presentWait = in_ext->presentWait;
+            out_ext->accelerationStructure = in_ext->accelerationStructure;
+            out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
+            out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
+            out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
+            out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
         {
-            VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentWait2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR;
+            VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->presentWait2 = in_ext->presentWait2;
+            out_ext->reportAddressBinding = in_ext->reportAddressBinding;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
         {
-            VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
+            VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAntiLagFeaturesAMD *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD;
             out_ext->pNext = NULL;
-            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
-            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
-            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
-            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
+            out_ext->antiLag = in_ext->antiLag;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
+            VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
+            out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
         {
-            VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
-            out_ext->pNext = NULL;
-            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
-        {
-            VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
+            VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->protectedMemory = in_ext->protectedMemory;
+            out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -16412,1631 +16403,1529 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
         {
-            VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
+            VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->multiDraw = in_ext->multiDraw;
+            out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
+            out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
         {
-            VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
+            VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
-            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
+            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
+            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
+            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
         {
-            VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
+            VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->maintenance4 = in_ext->maintenance4;
+            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
+            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
+            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
         {
-            VkPhysicalDeviceMaintenance5Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance5Features *in_ext = (const VkPhysicalDeviceMaintenance5Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
+            VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->maintenance5 = in_ext->maintenance5;
+            out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
         {
-            VkPhysicalDeviceMaintenance6Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance6Features *in_ext = (const VkPhysicalDeviceMaintenance6Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
+            VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
             out_ext->pNext = NULL;
-            out_ext->maintenance6 = in_ext->maintenance6;
+            out_ext->clustercullingShader = in_ext->clustercullingShader;
+            out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
         {
-            VkPhysicalDeviceMaintenance8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance8FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR;
+            VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
             out_ext->pNext = NULL;
-            out_ext->maintenance8 = in_ext->maintenance8;
+            out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
         {
-            VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance9FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR;
+            VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->maintenance9 = in_ext->maintenance9;
+            out_ext->colorWriteEnable = in_ext->colorWriteEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
+            VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
+            out_ext->commandBufferInheritance = in_ext->commandBufferInheritance;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
         {
-            VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
+            VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->shaderFloat16 = in_ext->shaderFloat16;
-            out_ext->shaderInt8 = in_ext->shaderInt8;
+            out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
+            out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
         {
-            VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
+            VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->hostQueryReset = in_ext->hostQueryReset;
+            out_ext->conditionalRendering = in_ext->conditionalRendering;
+            out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
         {
-            VkPhysicalDeviceGlobalPriorityQueryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceGlobalPriorityQueryFeatures *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
+            VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
+            out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope;
+            out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions;
+            out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions;
+            out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions;
+            out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations;
+            out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing;
+            out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
         {
-            VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
+            VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
-            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
-            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
-            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
-            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
-            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
-            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
-            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
-            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
-            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
-            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
-            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
-            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
-            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
+            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
+            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
         {
-            VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
+            VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
+            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
+            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
         {
-            VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
+            VkPhysicalDeviceCooperativeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCooperativeVectorFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
-            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
-            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
+            out_ext->cooperativeVector = in_ext->cooperativeVector;
+            out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
         {
-            VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
+            VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->conditionalRendering = in_ext->conditionalRendering;
-            out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
+            out_ext->indirectCopy = in_ext->indirectCopy;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
         {
-            VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
+            VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
-            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
-            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
+            out_ext->cornerSampledImage = in_ext->cornerSampledImage;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
+            VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
-            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
+            out_ext->coverageReductionMode = in_ext->coverageReductionMode;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
+            VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCubicClampFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
-            out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
-            out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
-            out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
-            out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
-            out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
-            out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
-            out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
-            out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
-            out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
-            out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
-            out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
+            out_ext->cubicRangeClamp = in_ext->cubicRangeClamp;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
-            out_ext->pNext = NULL;
-            out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
-            out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
-            out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
-            out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
-            out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
-            out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
-            out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
-            out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
-            out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
-            out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
-            out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
-            out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
+            VkPhysicalDeviceCubicWeightsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCubicWeightsFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM;
+            out_ext->pNext = NULL;
+            out_ext->selectableCubicWeights = in_ext->selectableCubicWeights;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
         {
-            VkPhysicalDeviceVertexAttributeDivisorFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVertexAttributeDivisorFeatures *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
+            VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
-            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
+            out_ext->customBorderColors = in_ext->customBorderColors;
+            out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM:
         {
-            VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
+            VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDataGraphFeaturesARM *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
+            out_ext->dataGraph = in_ext->dataGraph;
+            out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind;
+            out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants;
+            out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer;
+            out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
         {
-            VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
+            VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->transformFeedback = in_ext->transformFeedback;
-            out_ext->geometryStreams = in_ext->geometryStreams;
+            out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
+            VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthBiasControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
+            out_ext->depthBiasControl = in_ext->depthBiasControl;
+            out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
+            out_ext->floatRepresentation = in_ext->floatRepresentation;
+            out_ext->depthBiasExact = in_ext->depthBiasExact;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
+            VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClampControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->exclusiveScissor = in_ext->exclusiveScissor;
+            out_ext->depthClampControl = in_ext->depthClampControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
         {
-            VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
+            VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->cornerSampledImage = in_ext->cornerSampledImage;
+            out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
+            VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
-            out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
+            out_ext->depthClipControl = in_ext->depthClipControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
+            VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->imageFootprint = in_ext->imageFootprint;
+            out_ext->depthClipEnable = in_ext->depthClipEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
         {
-            VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
+            VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
+            out_ext->descriptorBuffer = in_ext->descriptorBuffer;
+            out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
+            out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
+            out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
         {
-            VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
+            VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->indirectCopy = in_ext->indirectCopy;
+            out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
         {
-            VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
+            VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->memoryDecompression = in_ext->memoryDecompression;
+            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
+            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
+            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
+            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
+            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
+            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
+            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
+            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
+            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
+            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
+            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
+            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
+            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
+            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
         {
-            VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
+            VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shadingRateImage = in_ext->shadingRateImage;
-            out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
+            out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
         {
-            VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
+            VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
             out_ext->pNext = NULL;
-            out_ext->invocationMask = in_ext->invocationMask;
+            out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
         {
-            VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
+            VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->taskShader = in_ext->taskShader;
-            out_ext->meshShader = in_ext->meshShader;
+            out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute;
+            out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines;
+            out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
         {
-            VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
+            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->taskShader = in_ext->taskShader;
-            out_ext->meshShader = in_ext->meshShader;
-            out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
-            out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
-            out_ext->meshShaderQueries = in_ext->meshShaderQueries;
+            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
+            out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
         {
-            VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
+            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->accelerationStructure = in_ext->accelerationStructure;
-            out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
-            out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
-            out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
-            out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
+            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
         {
-            VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
+            VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
-            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
-            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
-            out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
-            out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
+            out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
         {
-            VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
+            VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->rayQuery = in_ext->rayQuery;
+            out_ext->dynamicRendering = in_ext->dynamicRendering;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
         {
-            VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
+            VkPhysicalDeviceDynamicRenderingLocalReadFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
-            out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
+            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
         {
-            VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDeviceMemoryOverallocationCreateInfoAMD *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
+            VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->overallocationBehavior = in_ext->overallocationBehavior;
+            out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
         {
-            VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
+            VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
-            out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
-            out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
+            out_ext->exclusiveScissor = in_ext->exclusiveScissor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
+            VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
+            out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
+            out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
+            out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT;
+            VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
+            out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
+            out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
+            out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
+            out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
+            out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
+            out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
+            out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
+            out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
+            out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
+            out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
+            out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
+            out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
+            out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
+            out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
+            out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
+            out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
+            out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
+            out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
+            out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
+            out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
+            out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
+            out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
+            out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
+            out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
+            out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
+            out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
+            out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
+            out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
+            out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
+            out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
+            out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
         {
-            VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
+            VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
+            out_ext->extendedDynamicState = in_ext->extendedDynamicState;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
         {
-            VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
+            VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
+            out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
         {
-            VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
+            VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->depthClipEnable = in_ext->depthClipEnable;
+            out_ext->deviceFault = in_ext->deviceFault;
+            out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
         {
-            VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
+            VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFeatures2 *in_ext = (const VkPhysicalDeviceFeatures2 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
             out_ext->pNext = NULL;
-            out_ext->memoryPriority = in_ext->memoryPriority;
+            out_ext->features = in_ext->features;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
         {
-            VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
+            VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFormatPackFeaturesARM *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
+            out_ext->formatPack = in_ext->formatPack;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
         {
-            VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
+            VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
-            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
-            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
+            out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
         {
-            VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
+            VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
-            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
-            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
+            out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
+            out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
+            out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE:
         {
-            VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
+            VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE;
             out_ext->pNext = NULL;
-            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
         {
-            VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
+            VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
+            out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
         {
-            VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
+            VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
-            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
+            out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
         {
-            VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
+            VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
+            out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
+            out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
+            out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
         {
-            VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
+            VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->presentBarrier = in_ext->presentBarrier;
+            out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
+            out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
+            out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
         {
-            VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
+            VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
-            out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
+            out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
+            out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
+            out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
         {
-            VkPerformanceQueryReservationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPerformanceQueryReservationInfoKHR *in_ext = (const VkPerformanceQueryReservationInfoKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR;
+            VkPhysicalDeviceFrameBoundaryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFrameBoundaryFeaturesEXT *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->maxPerformanceQueriesPerPool = in_ext->maxPerformanceQueriesPerPool;
+            out_ext->frameBoundary = in_ext->frameBoundary;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
         {
-            VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
+            VkPhysicalDeviceGlobalPriorityQueryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceGlobalPriorityQueryFeatures *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->coverageReductionMode = in_ext->coverageReductionMode;
+            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
+            VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
+            out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
         {
-            VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
-            out_ext->pNext = NULL;
-            out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
-            out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
+            VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceHdrVividFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI;
+            out_ext->pNext = NULL;
+            out_ext->hdrVivid = in_ext->hdrVivid;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
         {
-            VkPhysicalDeviceIndexTypeUint8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceIndexTypeUint8Features *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
+            VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceHostImageCopyFeatures *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
+            out_ext->hostImageCopy = in_ext->hostImageCopy;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
         {
-            VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
+            VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
+            out_ext->hostQueryReset = in_ext->hostQueryReset;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
+            VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
-            out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
-            out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
+            out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
+            out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
         {
-            VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
+            VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA;
             out_ext->pNext = NULL;
-            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
+            out_ext->imageAlignmentControl = in_ext->imageAlignmentControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
+            VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
-            out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
+            out_ext->imageCompressionControl = in_ext->imageCompressionControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
+            VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
+            out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
+            VkPhysicalDeviceImageProcessing2FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageProcessing2FeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
+            out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
         {
-            VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
+            VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
+            out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
+            out_ext->textureBoxFilter = in_ext->textureBoxFilter;
+            out_ext->textureBlockMatch = in_ext->textureBlockMatch;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
         {
-            VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
+            VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
-            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
+            out_ext->robustImageAccess = in_ext->robustImageAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
         {
-            VkPhysicalDeviceLineRasterizationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceLineRasterizationFeatures *in_ext = (const VkPhysicalDeviceLineRasterizationFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
+            VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->rectangularLines = in_ext->rectangularLines;
-            out_ext->bresenhamLines = in_ext->bresenhamLines;
-            out_ext->smoothLines = in_ext->smoothLines;
-            out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
-            out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
-            out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
+            out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
+            VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
+            out_ext->minLod = in_ext->minLod;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
         {
-            VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
+            VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
-            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
-            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
-            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
-            out_ext->multiview = in_ext->multiview;
-            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
-            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
-            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
-            out_ext->variablePointers = in_ext->variablePointers;
-            out_ext->protectedMemory = in_ext->protectedMemory;
-            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
-            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
+            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
         {
-            VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
+            VkPhysicalDeviceIndexTypeUint8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceIndexTypeUint8Features *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
-            out_ext->drawIndirectCount = in_ext->drawIndirectCount;
-            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
-            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
-            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
-            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
-            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
-            out_ext->shaderFloat16 = in_ext->shaderFloat16;
-            out_ext->shaderInt8 = in_ext->shaderInt8;
-            out_ext->descriptorIndexing = in_ext->descriptorIndexing;
-            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
-            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
-            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
-            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
-            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
-            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
-            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
-            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
-            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
-            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
-            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
-            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
-            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
-            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
-            out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
-            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
-            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
-            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
-            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
-            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
-            out_ext->hostQueryReset = in_ext->hostQueryReset;
-            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
-            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
-            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
-            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
-            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
-            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
-            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
-            out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
-            out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
-            out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
+            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
         {
-            VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
+            VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
+            out_ext->pNext = NULL;
+            out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
+        {
+            VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->robustImageAccess = in_ext->robustImageAccess;
             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
-            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
-            out_ext->privateData = in_ext->privateData;
-            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
-            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
-            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
-            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
-            out_ext->synchronization2 = in_ext->synchronization2;
-            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
-            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
-            out_ext->dynamicRendering = in_ext->dynamicRendering;
-            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
-            out_ext->maintenance4 = in_ext->maintenance4;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
         {
-            VkPhysicalDeviceVulkan14Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkan14Features *in_ext = (const VkPhysicalDeviceVulkan14Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES;
+            VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
             out_ext->pNext = NULL;
-            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
-            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
-            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
-            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
-            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
-            out_ext->rectangularLines = in_ext->rectangularLines;
-            out_ext->bresenhamLines = in_ext->bresenhamLines;
-            out_ext->smoothLines = in_ext->smoothLines;
-            out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
-            out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
-            out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
-            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
-            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
-            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
-            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
-            out_ext->maintenance5 = in_ext->maintenance5;
-            out_ext->maintenance6 = in_ext->maintenance6;
-            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
-            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
-            out_ext->hostImageCopy = in_ext->hostImageCopy;
-            out_ext->pushDescriptor = in_ext->pushDescriptor;
+            out_ext->invocationMask = in_ext->invocationMask;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
         {
-            VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
+            VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
+            out_ext->legacyDithering = in_ext->legacyDithering;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
         {
-            VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
+            VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->customBorderColors = in_ext->customBorderColors;
-            out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
+            out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
         {
-            VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
+            VkPhysicalDeviceLineRasterizationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceLineRasterizationFeatures *in_ext = (const VkPhysicalDeviceLineRasterizationFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
-            out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
+            out_ext->rectangularLines = in_ext->rectangularLines;
+            out_ext->bresenhamLines = in_ext->bresenhamLines;
+            out_ext->smoothLines = in_ext->smoothLines;
+            out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
+            out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
+            out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
         {
-            VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
+            VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->extendedDynamicState = in_ext->extendedDynamicState;
+            out_ext->linearColorAttachment = in_ext->linearColorAttachment;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
         {
-            VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
+            VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
-            out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
-            out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
+            out_ext->maintenance4 = in_ext->maintenance4;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
         {
-            VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
+            VkPhysicalDeviceMaintenance5Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance5Features *in_ext = (const VkPhysicalDeviceMaintenance5Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
-            out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
-            out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
-            out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
-            out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
-            out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
-            out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
-            out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
-            out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
-            out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
-            out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
-            out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
-            out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
-            out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
-            out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
-            out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
-            out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
-            out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
-            out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
-            out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
-            out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
-            out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
-            out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
-            out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
-            out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
-            out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
-            out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
-            out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
-            out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
-            out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
-            out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
+            out_ext->maintenance5 = in_ext->maintenance5;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
         {
-            VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV;
+            VkPhysicalDeviceMaintenance6Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance6Features *in_ext = (const VkPhysicalDeviceMaintenance6Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure;
+            out_ext->maintenance6 = in_ext->maintenance6;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
         {
-            VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
+            VkPhysicalDeviceMaintenance8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance8FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
+            out_ext->maintenance8 = in_ext->maintenance8;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
         {
-            VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDeviceDiagnosticsConfigCreateInfoNV *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
+            VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance9FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
+            out_ext->maintenance9 = in_ext->maintenance9;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
         {
-            VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
+            VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
+            out_ext->memoryMapPlaced = in_ext->memoryMapPlaced;
+            out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced;
+            out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
+            VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
+            out_ext->memoryDecompression = in_ext->memoryDecompression;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
         {
-            VkPhysicalDeviceRobustness2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRobustness2FeaturesKHR *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
+            VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
-            out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
-            out_ext->nullDescriptor = in_ext->nullDescriptor;
+            out_ext->memoryPriority = in_ext->memoryPriority;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
         {
-            VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
+            VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->robustImageAccess = in_ext->robustImageAccess;
+            out_ext->taskShader = in_ext->taskShader;
+            out_ext->meshShader = in_ext->meshShader;
+            out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
+            out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
+            out_ext->meshShaderQueries = in_ext->meshShaderQueries;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
         {
-            VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
+            VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
-            out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
-            out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
-            out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
+            out_ext->taskShader = in_ext->taskShader;
+            out_ext->meshShader = in_ext->meshShader;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
         {
-            VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
+            VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
-            out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
+            out_ext->multiDraw = in_ext->multiDraw;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
         {
-            VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
+            VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->subpassShading = in_ext->subpassShading;
+            out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
         {
-            VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
+            VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->clustercullingShader = in_ext->clustercullingShader;
-            out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
+            out_ext->multiview = in_ext->multiview;
+            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
+            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
+            VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
-            out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
+            out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
         {
-            VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
+            VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
-            out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
-            out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
+            out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
+            VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
+            out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
+            VkPhysicalDeviceNestedCommandBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
-            out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
-            out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
+            out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer;
+            out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering;
+            out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
         {
-            VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
+            VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
-            out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
+            out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
         {
-            VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
+            VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
+            out_ext->micromap = in_ext->micromap;
+            out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
+            out_ext->micromapHostCommands = in_ext->micromapHostCommands;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
         {
-            VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
+            VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
+            out_ext->opticalFlow = in_ext->opticalFlow;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
         {
-            VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT;
+            VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes;
+            out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
         {
-            VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
+            VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
+            out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
         {
-            VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
+            VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->depthClipControl = in_ext->depthClipControl;
+            out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet;
+            out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
         {
-            VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT;
+            VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory;
+            out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
+            out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
+            VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineBinaryFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
-            out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout;
+            out_ext->pipelineBinaries = in_ext->pipelineBinaries;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
         {
-            VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthClampControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
+            VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC;
             out_ext->pNext = NULL;
-            out_ext->depthClampControl = in_ext->depthClampControl;
+            out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
         {
-            VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
+            VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
+            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
         {
-            VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR;
+            VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction;
+            out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
         {
-            VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
+            VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->colorWriteEnable = in_ext->colorWriteEnable;
+            out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
         {
-            VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
+            VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->synchronization2 = in_ext->synchronization2;
+            out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
         {
-            VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR;
+            VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts;
-            out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo;
+            out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
         {
-            VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceHostImageCopyFeatures *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
+            VkPhysicalDevicePipelineProtectedAccessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineProtectedAccessFeatures *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->hostImageCopy = in_ext->hostImageCopy;
+            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
         {
-            VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
+            VkPhysicalDevicePipelineRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineRobustnessFeatures *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
-            out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
-            out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
+            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
         {
-            VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
+            VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->legacyDithering = in_ext->legacyDithering;
+            out_ext->presentBarrier = in_ext->presentBarrier;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
         {
-            VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
+            VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentId2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
+            out_ext->presentId2 = in_ext->presentId2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
         {
-            VkPhysicalDevicePipelineProtectedAccessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineProtectedAccessFeatures *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
+            VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
+            out_ext->presentId = in_ext->presentId;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
         {
-            VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR;
+            VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->videoMaintenance1 = in_ext->videoMaintenance1;
+            out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
         {
-            VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR;
+            VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentWait2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9;
+            out_ext->presentWait2 = in_ext->presentWait2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
         {
-            VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR;
+            VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap;
+            out_ext->presentWait = in_ext->presentWait;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
         {
-            VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR;
+            VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1;
+            out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
+            out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
         {
-            VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
+            VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
+            out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
+            out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
+            out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
         {
-            VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
+            VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
+            out_ext->privateData = in_ext->privateData;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
         {
-            VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
+            VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->provokingVertexLast = in_ext->provokingVertexLast;
-            out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
+            out_ext->protectedMemory = in_ext->protectedMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
         {
-            VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR;
+            VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh;
+            out_ext->provokingVertexLast = in_ext->provokingVertexLast;
+            out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
         {
-            VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
+            VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->descriptorBuffer = in_ext->descriptorBuffer;
-            out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
-            out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
-            out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
+            out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
+            VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
+            out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
+            out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
+            out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
         {
-            VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
+            VkPhysicalDeviceRawAccessChainsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRawAccessChainsFeaturesNV *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
+            out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
         {
-            VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
+            VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
-            out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
+            out_ext->rayQuery = in_ext->rayQuery;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
         {
-            VkPhysicalDeviceRayTracingValidationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingValidationFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingValidationFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV;
+            VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->rayTracingValidation = in_ext->rayTracingValidation;
+            out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -18053,931 +17942,1042 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
         {
-            VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
+            VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
+            out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
+            out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
         {
-            VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
+            VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->dynamicRendering = in_ext->dynamicRendering;
+            out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
+            out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
         {
-            VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
+            VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->minLod = in_ext->minLod;
+            out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
+            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
+            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
+            out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
+            out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
         {
-            VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
+            VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
-            out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
-            out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
+            out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
         {
-            VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
+            VkPhysicalDeviceRayTracingValidationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingValidationFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingValidationFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->linearColorAttachment = in_ext->linearColorAttachment;
+            out_ext->rayTracingValidation = in_ext->rayTracingValidation;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
         {
-            VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
+            VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG;
             out_ext->pNext = NULL;
-            out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
+            out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
         {
-            VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineBinaryFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR;
+            VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRenderPassStripedFeaturesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->pipelineBinaries = in_ext->pipelineBinaries;
+            out_ext->renderPassStriped = in_ext->renderPassStriped;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
         {
-            VkDevicePipelineBinaryInternalCacheControlKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDevicePipelineBinaryInternalCacheControlKHR *in_ext = (const VkDevicePipelineBinaryInternalCacheControlKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR;
+            VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->disableInternalCache = in_ext->disableInternalCache;
+            out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
         {
-            VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
+            VkPhysicalDeviceRobustness2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRobustness2FeaturesKHR *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
+            out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
+            out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
+            out_ext->nullDescriptor = in_ext->nullDescriptor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
         {
-            VkPhysicalDeviceNestedCommandBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT;
+            VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer;
-            out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering;
-            out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse;
+            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
         {
-            VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
+            VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
+            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
         {
-            VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
+            VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSchedulingControlsFeaturesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->imageCompressionControl = in_ext->imageCompressionControl;
+            out_ext->schedulingControls = in_ext->schedulingControls;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
         {
-            VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
+            VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
+            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
         {
-            VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
+            VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
+            out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
         {
-            VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
+            VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->micromap = in_ext->micromap;
-            out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
-            out_ext->micromapHostCommands = in_ext->micromapHostCommands;
+            out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
+            out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
+            out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
+            out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
+            out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
+            out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
+            out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
+            out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
+            out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
+            out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
+            out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
+            out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
+            VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
+            out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
+            out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
+            out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
+            out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
+            out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
+            out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
+            out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
+            out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
+            out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
+            out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
+            out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
+            out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
         {
-            VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
+            VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
+            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
+            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
         {
-            VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
+            VkPhysicalDeviceShaderBfloat16FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderBfloat16FeaturesKHR *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
+            out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type;
+            out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct;
+            out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
         {
-            VkPhysicalDevicePipelineRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineRobustnessFeatures *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
+            VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
+            out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
+            out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
         {
-            VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
+            VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
-            out_ext->textureBoxFilter = in_ext->textureBoxFilter;
-            out_ext->textureBlockMatch = in_ext->textureBlockMatch;
+            out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
         {
-            VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
+            VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->tileProperties = in_ext->tileProperties;
+            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
         {
-            VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
+            VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
+            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
         {
-            VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
+            VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
             out_ext->pNext = NULL;
-            out_ext->reportAddressBinding = in_ext->reportAddressBinding;
+            out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
         {
-            VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
+            VkPhysicalDeviceShaderExpectAssumeFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderExpectAssumeFeatures *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->opticalFlow = in_ext->opticalFlow;
+            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
         {
-            VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
+            VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->deviceFault = in_ext->deviceFault;
-            out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
+            out_ext->shaderFloat16 = in_ext->shaderFloat16;
+            out_ext->shaderInt8 = in_ext->shaderInt8;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
+            VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderFloat8FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
+            out_ext->shaderFloat8 = in_ext->shaderFloat8;
+            out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
         {
-            VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
+            VkPhysicalDeviceShaderFloatControls2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderFloatControls2Features *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
+            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
         {
-            VkPhysicalDeviceFrameBoundaryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFrameBoundaryFeaturesEXT *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT;
+            VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->frameBoundary = in_ext->frameBoundary;
+            out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
+            out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
         {
-            VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
+            VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
+            out_ext->imageFootprint = in_ext->imageFootprint;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
         {
-            VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
+            VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
+            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
         {
-            VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthBiasControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
+            VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
             out_ext->pNext = NULL;
-            out_ext->depthBiasControl = in_ext->depthBiasControl;
-            out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
-            out_ext->floatRepresentation = in_ext->floatRepresentation;
-            out_ext->depthBiasExact = in_ext->depthBiasExact;
+            out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
         {
-            VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
+            VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
+            out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
         {
-            VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV;
+            VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace;
+            out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
         {
-            VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
+            VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
+            out_ext->shaderObject = in_ext->shaderObject;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
         {
-            VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
+            VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderQuadControlFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
+            out_ext->shaderQuadControl = in_ext->shaderQuadControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
         {
-            VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
+            VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
+            out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
+            VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderObject = in_ext->shaderObject;
+            out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderTileImageFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
+            VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
-            out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
-            out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
+            out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
         {
-            VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
+            VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
-            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
+            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
         {
-            VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAntiLagFeaturesAMD *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD;
+            VkPhysicalDeviceShaderSubgroupRotateFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderSubgroupRotateFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->antiLag = in_ext->antiLag;
+            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
+            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
         {
-            VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM;
+            VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->tileMemoryHeap = in_ext->tileMemoryHeap;
+            out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
         {
-            VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCubicClampFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM;
+            VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->cubicRangeClamp = in_ext->cubicRangeClamp;
+            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
         {
-            VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM;
+            VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderTileImageFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->ycbcrDegamma = in_ext->ycbcrDegamma;
+            out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
+            out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
+            out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
         {
-            VkPhysicalDeviceCubicWeightsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCubicWeightsFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM;
+            VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->selectableCubicWeights = in_ext->selectableCubicWeights;
+            out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
         {
-            VkPhysicalDeviceImageProcessing2FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageProcessing2FeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM;
+            VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2;
+            out_ext->shadingRateImage = in_ext->shadingRateImage;
+            out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
         {
-            VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV;
+            VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation;
+            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
+            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
         {
-            VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV;
+            VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet;
-            out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout;
+            out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
         {
-            VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDeviceQueueShaderCoreControlCreateInfoARM *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM;
+            VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
             out_ext->pNext = NULL;
-            out_ext->shaderCoreCount = in_ext->shaderCoreCount;
+            out_ext->subpassShading = in_ext->subpassShading;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
         {
-            VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSchedulingControlsFeaturesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM;
+            VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->schedulingControls = in_ext->schedulingControls;
+            out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
         {
-            VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG;
+            VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization;
+            out_ext->synchronization2 = in_ext->synchronization2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
         {
-            VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRenderPassStripedFeaturesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM;
+            VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTensorFeaturesARM *in_ext = (const VkPhysicalDeviceTensorFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->renderPassStriped = in_ext->renderPassStriped;
+            out_ext->tensorNonPacked = in_ext->tensorNonPacked;
+            out_ext->shaderTensorAccess = in_ext->shaderTensorAccess;
+            out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing;
+            out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing;
+            out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind;
+            out_ext->tensors = in_ext->tensors;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM;
+            VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap;
+            out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
         {
-            VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR;
+            VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence;
+            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderSubgroupRotateFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderSubgroupRotateFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
+            VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
-            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
+            out_ext->tileMemoryHeap = in_ext->tileMemoryHeap;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderExpectAssumeFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderExpectAssumeFeatures *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
+            VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
+            out_ext->tileProperties = in_ext->tileProperties;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderFloatControls2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderFloatControls2Features *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
+            VkPhysicalDeviceTileShadingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTileShadingFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
+            out_ext->tileShading = in_ext->tileShading;
+            out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage;
+            out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments;
+            out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments;
+            out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments;
+            out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments;
+            out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments;
+            out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw;
+            out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch;
+            out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile;
+            out_ext->tileShadingApron = in_ext->tileShadingApron;
+            out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron;
+            out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps;
+            out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
         {
-            VkPhysicalDeviceDynamicRenderingLocalReadFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
+            VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
+            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderQuadControlFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR;
+            VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderQuadControl = in_ext->shaderQuadControl;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
-        {
-            VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV;
-            out_ext->pNext = NULL;
-            out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics;
+            out_ext->transformFeedback = in_ext->transformFeedback;
+            out_ext->geometryStreams = in_ext->geometryStreams;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
         {
-            VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
+            VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->memoryMapPlaced = in_ext->memoryMapPlaced;
-            out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced;
-            out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve;
+            out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts;
+            out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
         {
-            VkPhysicalDeviceShaderBfloat16FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderBfloat16FeaturesKHR *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR;
+            VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type;
-            out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct;
-            out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix;
+            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
         {
-            VkPhysicalDeviceRawAccessChainsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRawAccessChainsFeaturesNV *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV;
+            VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains;
+            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
+            out_ext->variablePointers = in_ext->variablePointers;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
         {
-            VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV;
+            VkPhysicalDeviceVertexAttributeDivisorFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVertexAttributeDivisorFeatures *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->commandBufferInheritance = in_ext->commandBufferInheritance;
+            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
+            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
         {
-            VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA;
+            VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->imageAlignmentControl = in_ext->imageAlignmentControl;
+            out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT;
+            VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites;
+            out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
         {
-            VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR;
+            VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady;
+            out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
         {
-            VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV;
+            VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope;
-            out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions;
-            out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions;
-            out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions;
-            out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations;
-            out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing;
-            out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads;
+            out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
         {
-            VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceHdrVividFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI;
+            VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->hdrVivid = in_ext->hdrVivid;
+            out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
         {
-            VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT;
+            VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness;
+            out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
         {
-            VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
+            VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
+            out_ext->videoMaintenance1 = in_ext->videoMaintenance1;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
         {
-            VkPhysicalDeviceCooperativeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCooperativeVectorFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV;
+            VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->cooperativeVector = in_ext->cooperativeVector;
-            out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining;
+            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
+            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
+            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
+            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
+            out_ext->multiview = in_ext->multiview;
+            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
+            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
+            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
+            out_ext->variablePointers = in_ext->variablePointers;
+            out_ext->protectedMemory = in_ext->protectedMemory;
+            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
+            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
         {
-            VkPhysicalDeviceTileShadingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTileShadingFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM;
+            VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->tileShading = in_ext->tileShading;
-            out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage;
-            out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments;
-            out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments;
-            out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments;
-            out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments;
-            out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments;
-            out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw;
-            out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch;
-            out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile;
-            out_ext->tileShadingApron = in_ext->tileShadingApron;
-            out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron;
-            out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps;
-            out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing;
+            out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
+            out_ext->drawIndirectCount = in_ext->drawIndirectCount;
+            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
+            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
+            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
+            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
+            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
+            out_ext->shaderFloat16 = in_ext->shaderFloat16;
+            out_ext->shaderInt8 = in_ext->shaderInt8;
+            out_ext->descriptorIndexing = in_ext->descriptorIndexing;
+            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
+            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
+            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
+            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
+            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
+            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
+            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
+            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
+            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
+            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
+            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
+            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
+            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
+            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
+            out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
+            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
+            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
+            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
+            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
+            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
+            out_ext->hostQueryReset = in_ext->hostQueryReset;
+            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
+            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
+            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
+            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
+            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
+            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
+            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
+            out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
+            out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
+            out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
         {
-            VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE;
+            VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
             out_ext->pNext = NULL;
+            out_ext->robustImageAccess = in_ext->robustImageAccess;
+            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
+            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
+            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
+            out_ext->privateData = in_ext->privateData;
+            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
+            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
+            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
+            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
+            out_ext->synchronization2 = in_ext->synchronization2;
+            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
+            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
+            out_ext->dynamicRendering = in_ext->dynamicRendering;
+            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
+            out_ext->maintenance4 = in_ext->maintenance4;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
         {
-            VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFormatPackFeaturesARM *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM;
+            VkPhysicalDeviceVulkan14Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkan14Features *in_ext = (const VkPhysicalDeviceVulkan14Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->formatPack = in_ext->formatPack;
+            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
+            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
+            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
+            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
+            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
+            out_ext->rectangularLines = in_ext->rectangularLines;
+            out_ext->bresenhamLines = in_ext->bresenhamLines;
+            out_ext->smoothLines = in_ext->smoothLines;
+            out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
+            out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
+            out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
+            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
+            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
+            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
+            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
+            out_ext->maintenance5 = in_ext->maintenance5;
+            out_ext->maintenance6 = in_ext->maintenance6;
+            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
+            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
+            out_ext->hostImageCopy = in_ext->hostImageCopy;
+            out_ext->pushDescriptor = in_ext->pushDescriptor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
         {
-            VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTensorFeaturesARM *in_ext = (const VkPhysicalDeviceTensorFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM;
+            VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->tensorNonPacked = in_ext->tensorNonPacked;
-            out_ext->shaderTensorAccess = in_ext->shaderTensorAccess;
-            out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing;
-            out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing;
-            out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind;
-            out_ext->tensors = in_ext->tensors;
+            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
+            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
+            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
         {
-            VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM;
+            VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors;
+            out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
+            out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
+            out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
+            out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderFloat8FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT;
+            VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderFloat8 = in_ext->shaderFloat8;
-            out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix;
+            out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
         {
-            VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDataGraphFeaturesARM *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM;
+            VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->dataGraph = in_ext->dataGraph;
-            out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind;
-            out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants;
-            out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer;
-            out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule;
+            out_ext->ycbcrDegamma = in_ext->ycbcrDegamma;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC;
+            VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode;
+            out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR;
+            VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers;
+            out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
+        {
+            VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
+            out_ext->pNext = NULL;
+            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -19109,198 +19109,189 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *
         {
         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
+            VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDeviceDiagnosticsConfigCreateInfoNV32 *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
+            out_ext->flags = in_ext->flags;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
+            VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDeviceGroupDeviceCreateInfo32 *in_ext = (const VkDeviceGroupDeviceCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute;
-            out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines;
-            out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay;
+            out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
+            out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->pPhysicalDevices), in_ext->physicalDeviceCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
         {
-            VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDevicePrivateDataCreateInfo32 *in_ext = (const VkDevicePrivateDataCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
+            VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDeviceMemoryOverallocationCreateInfoAMD32 *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
             out_ext->pNext = NULL;
-            out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
+            out_ext->overallocationBehavior = in_ext->overallocationBehavior;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
+        case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
         {
-            VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
+            VkDevicePipelineBinaryInternalCacheControlKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDevicePipelineBinaryInternalCacheControlKHR32 *in_ext = (const VkDevicePipelineBinaryInternalCacheControlKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR;
             out_ext->pNext = NULL;
-            out_ext->privateData = in_ext->privateData;
+            out_ext->disableInternalCache = in_ext->disableInternalCache;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
         {
-            VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV;
+            VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDevicePrivateDataCreateInfo32 *in_ext = (const VkDevicePrivateDataCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure;
+            out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
         {
-            VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFeatures232 *in_ext = (const VkPhysicalDeviceFeatures232 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+            VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDeviceQueueShaderCoreControlCreateInfoARM32 *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM;
             out_ext->pNext = NULL;
-            out_ext->features = in_ext->features;
+            out_ext->shaderCoreCount = in_ext->shaderCoreCount;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR:
         {
-            VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
+            VkPerformanceQueryReservationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPerformanceQueryReservationInfoKHR32 *in_ext = (const VkPerformanceQueryReservationInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
-            out_ext->variablePointers = in_ext->variablePointers;
+            out_ext->maxPerformanceQueriesPerPool = in_ext->maxPerformanceQueriesPerPool;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
         {
-            VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
+            VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->multiview = in_ext->multiview;
-            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
-            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
+            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
+            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
+            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
+            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
         {
-            VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDeviceGroupDeviceCreateInfo32 *in_ext = (const VkDeviceGroupDeviceCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
+            VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
-            out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->pPhysicalDevices), in_ext->physicalDeviceCount);
+            out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
+            out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
         {
-            VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
+            VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->presentId = in_ext->presentId;
+            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
+            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
+            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
         {
-            VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentId2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR;
+            VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->presentId2 = in_ext->presentId2;
+            out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
         {
-            VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
+            VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->presentWait = in_ext->presentWait;
+            out_ext->accelerationStructure = in_ext->accelerationStructure;
+            out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
+            out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
+            out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
+            out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
         {
-            VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentWait2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR;
+            VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->presentWait2 = in_ext->presentWait2;
+            out_ext->reportAddressBinding = in_ext->reportAddressBinding;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
-        {
-            VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
-            out_ext->pNext = NULL;
-            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
-            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
-            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
-            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
         {
-            VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
+            VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAntiLagFeaturesAMD32 *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD;
             out_ext->pNext = NULL;
-            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
+            out_ext->antiLag = in_ext->antiLag;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
         {
-            VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
+            VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
+            out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
         {
-            VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
+            VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->protectedMemory = in_ext->protectedMemory;
+            out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -19316,1631 +19307,1529 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
         {
-            VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
+            VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->multiDraw = in_ext->multiDraw;
+            out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
+            out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
         {
-            VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
+            VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
-            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
+            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
+            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
+            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
         {
-            VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
+            VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->maintenance4 = in_ext->maintenance4;
+            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
+            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
+            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
         {
-            VkPhysicalDeviceMaintenance5Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance5Features32 *in_ext = (const VkPhysicalDeviceMaintenance5Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
+            VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->maintenance5 = in_ext->maintenance5;
+            out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
         {
-            VkPhysicalDeviceMaintenance6Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance6Features32 *in_ext = (const VkPhysicalDeviceMaintenance6Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
+            VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
             out_ext->pNext = NULL;
-            out_ext->maintenance6 = in_ext->maintenance6;
+            out_ext->clustercullingShader = in_ext->clustercullingShader;
+            out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
         {
-            VkPhysicalDeviceMaintenance8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance8FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR;
+            VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
             out_ext->pNext = NULL;
-            out_ext->maintenance8 = in_ext->maintenance8;
+            out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
         {
-            VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR;
+            VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->maintenance9 = in_ext->maintenance9;
+            out_ext->colorWriteEnable = in_ext->colorWriteEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
+            VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
+            out_ext->commandBufferInheritance = in_ext->commandBufferInheritance;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
         {
-            VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
+            VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->shaderFloat16 = in_ext->shaderFloat16;
-            out_ext->shaderInt8 = in_ext->shaderInt8;
+            out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
+            out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
         {
-            VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
+            VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->hostQueryReset = in_ext->hostQueryReset;
+            out_ext->conditionalRendering = in_ext->conditionalRendering;
+            out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
         {
-            VkPhysicalDeviceGlobalPriorityQueryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
+            VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
+            out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope;
+            out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions;
+            out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions;
+            out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions;
+            out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations;
+            out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing;
+            out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
         {
-            VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
+            VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
-            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
-            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
-            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
-            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
-            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
-            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
-            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
-            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
-            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
-            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
-            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
-            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
-            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
+            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
+            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
         {
-            VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
+            VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
+            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
+            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
         {
-            VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
+            VkPhysicalDeviceCooperativeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
-            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
-            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
+            out_ext->cooperativeVector = in_ext->cooperativeVector;
+            out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
         {
-            VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
+            VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->conditionalRendering = in_ext->conditionalRendering;
-            out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
+            out_ext->indirectCopy = in_ext->indirectCopy;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
         {
-            VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
+            VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
-            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
-            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
+            out_ext->cornerSampledImage = in_ext->cornerSampledImage;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
+            VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
-            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
+            out_ext->coverageReductionMode = in_ext->coverageReductionMode;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
+            VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCubicClampFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
-            out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
-            out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
-            out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
-            out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
-            out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
-            out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
-            out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
-            out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
-            out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
-            out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
-            out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
+            out_ext->cubicRangeClamp = in_ext->cubicRangeClamp;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
+            VkPhysicalDeviceCubicWeightsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
-            out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
-            out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
-            out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
-            out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
-            out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
-            out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
-            out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
-            out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
-            out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
-            out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
-            out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
+            out_ext->selectableCubicWeights = in_ext->selectableCubicWeights;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
         {
-            VkPhysicalDeviceVertexAttributeDivisorFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
+            VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
-            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
+            out_ext->customBorderColors = in_ext->customBorderColors;
+            out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM:
         {
-            VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
+            VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDataGraphFeaturesARM32 *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
+            out_ext->dataGraph = in_ext->dataGraph;
+            out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind;
+            out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants;
+            out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer;
+            out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
         {
-            VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
+            VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->transformFeedback = in_ext->transformFeedback;
-            out_ext->geometryStreams = in_ext->geometryStreams;
+            out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
+            VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
+            out_ext->depthBiasControl = in_ext->depthBiasControl;
+            out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
+            out_ext->floatRepresentation = in_ext->floatRepresentation;
+            out_ext->depthBiasExact = in_ext->depthBiasExact;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
+            VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->exclusiveScissor = in_ext->exclusiveScissor;
+            out_ext->depthClampControl = in_ext->depthClampControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
         {
-            VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
+            VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->cornerSampledImage = in_ext->cornerSampledImage;
+            out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
+            VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
-            out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
+            out_ext->depthClipControl = in_ext->depthClipControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
+            VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->imageFootprint = in_ext->imageFootprint;
+            out_ext->depthClipEnable = in_ext->depthClipEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
         {
-            VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
+            VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
+            out_ext->descriptorBuffer = in_ext->descriptorBuffer;
+            out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
+            out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
+            out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
         {
-            VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
+            VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->indirectCopy = in_ext->indirectCopy;
+            out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
         {
-            VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
+            VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->memoryDecompression = in_ext->memoryDecompression;
+            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
+            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
+            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
+            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
+            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
+            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
+            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
+            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
+            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
+            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
+            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
+            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
+            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
+            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
         {
-            VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
+            VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shadingRateImage = in_ext->shadingRateImage;
-            out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
+            out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
         {
-            VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
+            VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
             out_ext->pNext = NULL;
-            out_ext->invocationMask = in_ext->invocationMask;
+            out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
         {
-            VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
+            VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->taskShader = in_ext->taskShader;
-            out_ext->meshShader = in_ext->meshShader;
+            out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute;
+            out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines;
+            out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
         {
-            VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
+            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->taskShader = in_ext->taskShader;
-            out_ext->meshShader = in_ext->meshShader;
-            out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
-            out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
-            out_ext->meshShaderQueries = in_ext->meshShaderQueries;
+            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
+            out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
         {
-            VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
+            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->accelerationStructure = in_ext->accelerationStructure;
-            out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
-            out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
-            out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
-            out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
+            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
         {
-            VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
-            out_ext->pNext = NULL;
-            out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
-            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
-            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
-            out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
-            out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
+            VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
+            out_ext->pNext = NULL;
+            out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
         {
-            VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
+            VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->rayQuery = in_ext->rayQuery;
+            out_ext->dynamicRendering = in_ext->dynamicRendering;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
         {
-            VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
+            VkPhysicalDeviceDynamicRenderingLocalReadFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
-            out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
+            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
         {
-            VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDeviceMemoryOverallocationCreateInfoAMD32 *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
+            VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->overallocationBehavior = in_ext->overallocationBehavior;
+            out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
         {
-            VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
+            VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
-            out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
-            out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
+            out_ext->exclusiveScissor = in_ext->exclusiveScissor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
+            VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
+            out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
+            out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
+            out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT;
+            VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
+            out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
+            out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
+            out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
+            out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
+            out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
+            out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
+            out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
+            out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
+            out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
+            out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
+            out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
+            out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
+            out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
+            out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
+            out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
+            out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
+            out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
+            out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
+            out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
+            out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
+            out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
+            out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
+            out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
+            out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
+            out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
+            out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
+            out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
+            out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
+            out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
+            out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
+            out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
         {
-            VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
+            VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
+            out_ext->extendedDynamicState = in_ext->extendedDynamicState;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
         {
-            VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
+            VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
+            out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
         {
-            VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
+            VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->depthClipEnable = in_ext->depthClipEnable;
+            out_ext->deviceFault = in_ext->deviceFault;
+            out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
         {
-            VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
+            VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFeatures232 *in_ext = (const VkPhysicalDeviceFeatures232 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
             out_ext->pNext = NULL;
-            out_ext->memoryPriority = in_ext->memoryPriority;
+            out_ext->features = in_ext->features;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
         {
-            VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
+            VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFormatPackFeaturesARM32 *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
+            out_ext->formatPack = in_ext->formatPack;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
         {
-            VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
+            VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
-            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
-            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
+            out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
         {
-            VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
+            VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
-            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
-            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
+            out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
+            out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
+            out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE:
         {
-            VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
+            VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE;
             out_ext->pNext = NULL;
-            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
         {
-            VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
+            VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
+            out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
         {
-            VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
+            VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
-            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
+            out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
         {
-            VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
+            VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
+            out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
+            out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
+            out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
         {
-            VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
+            VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->presentBarrier = in_ext->presentBarrier;
+            out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
+            out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
+            out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
         {
-            VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
+            VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
-            out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
+            out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
+            out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
+            out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
         {
-            VkPerformanceQueryReservationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPerformanceQueryReservationInfoKHR32 *in_ext = (const VkPerformanceQueryReservationInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR;
+            VkPhysicalDeviceFrameBoundaryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->maxPerformanceQueriesPerPool = in_ext->maxPerformanceQueriesPerPool;
+            out_ext->frameBoundary = in_ext->frameBoundary;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
         {
-            VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
+            VkPhysicalDeviceGlobalPriorityQueryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->coverageReductionMode = in_ext->coverageReductionMode;
+            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
+            VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
+            out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
         {
-            VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
+            VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI;
             out_ext->pNext = NULL;
-            out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
-            out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
+            out_ext->hdrVivid = in_ext->hdrVivid;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
         {
-            VkPhysicalDeviceIndexTypeUint8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceIndexTypeUint8Features32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
+            VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceHostImageCopyFeatures32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
+            out_ext->hostImageCopy = in_ext->hostImageCopy;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
         {
-            VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
+            VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
+            out_ext->hostQueryReset = in_ext->hostQueryReset;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
+            VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
-            out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
-            out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
+            out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
+            out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
         {
-            VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
+            VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA;
             out_ext->pNext = NULL;
-            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
+            out_ext->imageAlignmentControl = in_ext->imageAlignmentControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
+            VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
-            out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
+            out_ext->imageCompressionControl = in_ext->imageCompressionControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
+            VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
+            out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
+            VkPhysicalDeviceImageProcessing2FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
+            out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
         {
-            VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
+            VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
+            out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
+            out_ext->textureBoxFilter = in_ext->textureBoxFilter;
+            out_ext->textureBlockMatch = in_ext->textureBlockMatch;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
         {
-            VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
+            VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
-            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
+            out_ext->robustImageAccess = in_ext->robustImageAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
         {
-            VkPhysicalDeviceLineRasterizationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceLineRasterizationFeatures32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
+            VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->rectangularLines = in_ext->rectangularLines;
-            out_ext->bresenhamLines = in_ext->bresenhamLines;
-            out_ext->smoothLines = in_ext->smoothLines;
-            out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
-            out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
-            out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
+            out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
+            VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
+            out_ext->minLod = in_ext->minLod;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
         {
-            VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
+            VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
-            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
-            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
-            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
-            out_ext->multiview = in_ext->multiview;
-            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
-            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
-            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
-            out_ext->variablePointers = in_ext->variablePointers;
-            out_ext->protectedMemory = in_ext->protectedMemory;
-            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
-            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
+            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
         {
-            VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
+            VkPhysicalDeviceIndexTypeUint8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceIndexTypeUint8Features32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
-            out_ext->drawIndirectCount = in_ext->drawIndirectCount;
-            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
-            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
-            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
-            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
-            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
-            out_ext->shaderFloat16 = in_ext->shaderFloat16;
-            out_ext->shaderInt8 = in_ext->shaderInt8;
-            out_ext->descriptorIndexing = in_ext->descriptorIndexing;
-            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
-            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
-            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
-            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
-            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
-            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
-            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
-            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
-            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
-            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
-            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
-            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
-            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
-            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
-            out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
-            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
-            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
-            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
-            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
-            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
-            out_ext->hostQueryReset = in_ext->hostQueryReset;
-            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
-            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
-            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
-            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
-            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
-            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
-            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
-            out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
-            out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
-            out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
+            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
         {
-            VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
+            VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->robustImageAccess = in_ext->robustImageAccess;
-            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
-            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
-            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
-            out_ext->privateData = in_ext->privateData;
-            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
-            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
-            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
-            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
-            out_ext->synchronization2 = in_ext->synchronization2;
-            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
-            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
-            out_ext->dynamicRendering = in_ext->dynamicRendering;
-            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
-            out_ext->maintenance4 = in_ext->maintenance4;
+            out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
         {
-            VkPhysicalDeviceVulkan14Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkan14Features32 *in_ext = (const VkPhysicalDeviceVulkan14Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES;
+            VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
-            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
-            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
-            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
-            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
-            out_ext->rectangularLines = in_ext->rectangularLines;
-            out_ext->bresenhamLines = in_ext->bresenhamLines;
-            out_ext->smoothLines = in_ext->smoothLines;
-            out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
-            out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
-            out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
-            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
-            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
-            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
-            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
-            out_ext->maintenance5 = in_ext->maintenance5;
-            out_ext->maintenance6 = in_ext->maintenance6;
-            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
-            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
-            out_ext->hostImageCopy = in_ext->hostImageCopy;
-            out_ext->pushDescriptor = in_ext->pushDescriptor;
+            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
+            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
         {
-            VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
+            VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
             out_ext->pNext = NULL;
-            out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
+            out_ext->invocationMask = in_ext->invocationMask;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
         {
-            VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
+            VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->customBorderColors = in_ext->customBorderColors;
-            out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
+            out_ext->legacyDithering = in_ext->legacyDithering;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
         {
-            VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
+            VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
-            out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
+            out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
         {
-            VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
+            VkPhysicalDeviceLineRasterizationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceLineRasterizationFeatures32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->extendedDynamicState = in_ext->extendedDynamicState;
+            out_ext->rectangularLines = in_ext->rectangularLines;
+            out_ext->bresenhamLines = in_ext->bresenhamLines;
+            out_ext->smoothLines = in_ext->smoothLines;
+            out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
+            out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
+            out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
         {
-            VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
+            VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
-            out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
-            out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
+            out_ext->linearColorAttachment = in_ext->linearColorAttachment;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
         {
-            VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
+            VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
-            out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
-            out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
-            out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
-            out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
-            out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
-            out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
-            out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
-            out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
-            out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
-            out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
-            out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
-            out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
-            out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
-            out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
-            out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
-            out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
-            out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
-            out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
-            out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
-            out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
-            out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
-            out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
-            out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
-            out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
-            out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
-            out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
-            out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
-            out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
-            out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
-            out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
+            out_ext->maintenance4 = in_ext->maintenance4;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
         {
-            VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV;
+            VkPhysicalDeviceMaintenance5Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance5Features32 *in_ext = (const VkPhysicalDeviceMaintenance5Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure;
+            out_ext->maintenance5 = in_ext->maintenance5;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
         {
-            VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
+            VkPhysicalDeviceMaintenance6Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance6Features32 *in_ext = (const VkPhysicalDeviceMaintenance6Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
+            out_ext->maintenance6 = in_ext->maintenance6;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
         {
-            VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDeviceDiagnosticsConfigCreateInfoNV32 *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
+            VkPhysicalDeviceMaintenance8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance8FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
+            out_ext->maintenance8 = in_ext->maintenance8;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
         {
-            VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
+            VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
+            out_ext->maintenance9 = in_ext->maintenance9;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
+            VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
+            out_ext->memoryMapPlaced = in_ext->memoryMapPlaced;
+            out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced;
+            out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
         {
-            VkPhysicalDeviceRobustness2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRobustness2FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
+            VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
-            out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
-            out_ext->nullDescriptor = in_ext->nullDescriptor;
+            out_ext->memoryDecompression = in_ext->memoryDecompression;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
         {
-            VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
+            VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->robustImageAccess = in_ext->robustImageAccess;
+            out_ext->memoryPriority = in_ext->memoryPriority;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
         {
-            VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
+            VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
-            out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
-            out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
-            out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
+            out_ext->taskShader = in_ext->taskShader;
+            out_ext->meshShader = in_ext->meshShader;
+            out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
+            out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
+            out_ext->meshShaderQueries = in_ext->meshShaderQueries;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
         {
-            VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
+            VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
-            out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
+            out_ext->taskShader = in_ext->taskShader;
+            out_ext->meshShader = in_ext->meshShader;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
         {
-            VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
+            VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->subpassShading = in_ext->subpassShading;
+            out_ext->multiDraw = in_ext->multiDraw;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
         {
-            VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
+            VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->clustercullingShader = in_ext->clustercullingShader;
-            out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
+            out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
         {
-            VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
+            VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
-            out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
+            out_ext->multiview = in_ext->multiview;
+            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
+            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
         {
-            VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
+            VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
-            out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
-            out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
+            out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
+            VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
+            out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
+            VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
-            out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
-            out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
+            out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
         {
-            VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
+            VkPhysicalDeviceNestedCommandBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
-            out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
+            out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer;
+            out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering;
+            out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
         {
-            VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
+            VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
+            out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
         {
-            VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
+            VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
+            out_ext->micromap = in_ext->micromap;
+            out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
+            out_ext->micromapHostCommands = in_ext->micromapHostCommands;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
         {
-            VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT;
+            VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes;
+            out_ext->opticalFlow = in_ext->opticalFlow;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
         {
-            VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
+            VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
+            out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
         {
-            VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
+            VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->depthClipControl = in_ext->depthClipControl;
+            out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
         {
-            VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT;
+            VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory;
+            out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet;
+            out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
+            VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
-            out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout;
+            out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
+            out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
         {
-            VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
+            VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->depthClampControl = in_ext->depthClampControl;
+            out_ext->pipelineBinaries = in_ext->pipelineBinaries;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
         {
-            VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
+            VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC;
             out_ext->pNext = NULL;
-            out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
+            out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
         {
-            VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR;
+            VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction;
+            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
         {
-            VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
+            VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->colorWriteEnable = in_ext->colorWriteEnable;
+            out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
         {
-            VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
+            VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->synchronization2 = in_ext->synchronization2;
+            out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
         {
-            VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR;
+            VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts;
-            out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo;
+            out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
         {
-            VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceHostImageCopyFeatures32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
+            VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->hostImageCopy = in_ext->hostImageCopy;
+            out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
         {
-            VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
+            VkPhysicalDevicePipelineProtectedAccessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineProtectedAccessFeatures32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
-            out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
-            out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
+            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
         {
-            VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
+            VkPhysicalDevicePipelineRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineRobustnessFeatures32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->legacyDithering = in_ext->legacyDithering;
+            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
         {
-            VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
+            VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
+            out_ext->presentBarrier = in_ext->presentBarrier;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
         {
-            VkPhysicalDevicePipelineProtectedAccessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineProtectedAccessFeatures32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
+            VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentId2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
+            out_ext->presentId2 = in_ext->presentId2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
         {
-            VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR;
+            VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->videoMaintenance1 = in_ext->videoMaintenance1;
+            out_ext->presentId = in_ext->presentId;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
         {
-            VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR;
+            VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9;
+            out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
         {
-            VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR;
+            VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentWait2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap;
+            out_ext->presentWait2 = in_ext->presentWait2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
         {
-            VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR;
+            VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1;
+            out_ext->presentWait = in_ext->presentWait;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
         {
-            VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
+            VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
+            out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
+            out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
         {
-            VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
+            VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
+            out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
+            out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
+            out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
         {
-            VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
+            VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->provokingVertexLast = in_ext->provokingVertexLast;
-            out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
+            out_ext->privateData = in_ext->privateData;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
         {
-            VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR;
+            VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh;
+            out_ext->protectedMemory = in_ext->protectedMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
         {
-            VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
+            VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->descriptorBuffer = in_ext->descriptorBuffer;
-            out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
-            out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
-            out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
+            out_ext->provokingVertexLast = in_ext->provokingVertexLast;
+            out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
+            VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
+            out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
+            VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
+            out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
+            out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
+            out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
         {
-            VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
+            VkPhysicalDeviceRawAccessChainsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
-            out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
+            out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
         {
-            VkPhysicalDeviceRayTracingValidationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV;
+            VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->rayTracingValidation = in_ext->rayTracingValidation;
+            out_ext->rayQuery = in_ext->rayQuery;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
+        {
+            VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
+            out_ext->pNext = NULL;
+            out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -20957,777 +20846,748 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
         {
-            VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
+            VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
+            out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
+            out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
         {
-            VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
+            VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->dynamicRendering = in_ext->dynamicRendering;
+            out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
+            out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
         {
-            VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
+            VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->minLod = in_ext->minLod;
+            out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
+            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
+            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
+            out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
+            out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
         {
-            VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
+            VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
-            out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
-            out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
+            out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
         {
-            VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
+            VkPhysicalDeviceRayTracingValidationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->linearColorAttachment = in_ext->linearColorAttachment;
+            out_ext->rayTracingValidation = in_ext->rayTracingValidation;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
         {
-            VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
+            VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG;
             out_ext->pNext = NULL;
-            out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
+            out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
         {
-            VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR;
+            VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->pipelineBinaries = in_ext->pipelineBinaries;
+            out_ext->renderPassStriped = in_ext->renderPassStriped;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
         {
-            VkDevicePipelineBinaryInternalCacheControlKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDevicePipelineBinaryInternalCacheControlKHR32 *in_ext = (const VkDevicePipelineBinaryInternalCacheControlKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR;
+            VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->disableInternalCache = in_ext->disableInternalCache;
+            out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
         {
-            VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
+            VkPhysicalDeviceRobustness2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRobustness2FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
+            out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
+            out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
+            out_ext->nullDescriptor = in_ext->nullDescriptor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
         {
-            VkPhysicalDeviceNestedCommandBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT;
+            VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer;
-            out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering;
-            out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse;
+            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
         {
-            VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
+            VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
+            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
         {
-            VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
+            VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->imageCompressionControl = in_ext->imageCompressionControl;
+            out_ext->schedulingControls = in_ext->schedulingControls;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
         {
-            VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
+            VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
+            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
         {
-            VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
+            VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
+            out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
         {
-            VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
+            VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->micromap = in_ext->micromap;
-            out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
-            out_ext->micromapHostCommands = in_ext->micromapHostCommands;
+            out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
+            out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
+            out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
+            out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
+            out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
+            out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
+            out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
+            out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
+            out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
+            out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
+            out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
+            out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
+            VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
+            out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
+            out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
+            out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
+            out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
+            out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
+            out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
+            out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
+            out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
+            out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
+            out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
+            out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
+            out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
         {
-            VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
+            VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
+            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
+            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
         {
-            VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
+            VkPhysicalDeviceShaderBfloat16FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
+            out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type;
+            out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct;
+            out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
         {
-            VkPhysicalDevicePipelineRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineRobustnessFeatures32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
+            VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
+            out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
+            out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
         {
-            VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
+            VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
-            out_ext->textureBoxFilter = in_ext->textureBoxFilter;
-            out_ext->textureBlockMatch = in_ext->textureBlockMatch;
+            out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
         {
-            VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
+            VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->tileProperties = in_ext->tileProperties;
+            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
         {
-            VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
+            VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
+            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
         {
-            VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
+            VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
             out_ext->pNext = NULL;
-            out_ext->reportAddressBinding = in_ext->reportAddressBinding;
+            out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
         {
-            VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
+            VkPhysicalDeviceShaderExpectAssumeFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderExpectAssumeFeatures32 *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->opticalFlow = in_ext->opticalFlow;
+            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
         {
-            VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
+            VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->deviceFault = in_ext->deviceFault;
-            out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
+            out_ext->shaderFloat16 = in_ext->shaderFloat16;
+            out_ext->shaderInt8 = in_ext->shaderInt8;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
+            VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
+            out_ext->shaderFloat8 = in_ext->shaderFloat8;
+            out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
         {
-            VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
+            VkPhysicalDeviceShaderFloatControls2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderFloatControls2Features32 *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
+            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
         {
-            VkPhysicalDeviceFrameBoundaryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT;
+            VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->frameBoundary = in_ext->frameBoundary;
+            out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
+            out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
         {
-            VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
+            VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
+            out_ext->imageFootprint = in_ext->imageFootprint;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
         {
-            VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
+            VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
+            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
         {
-            VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
+            VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
             out_ext->pNext = NULL;
-            out_ext->depthBiasControl = in_ext->depthBiasControl;
-            out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
-            out_ext->floatRepresentation = in_ext->floatRepresentation;
-            out_ext->depthBiasExact = in_ext->depthBiasExact;
+            out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
         {
-            VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
+            VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
+            out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
         {
-            VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV;
+            VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace;
+            out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
         {
-            VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
+            VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
+            out_ext->shaderObject = in_ext->shaderObject;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
         {
-            VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
+            VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
+            out_ext->shaderQuadControl = in_ext->shaderQuadControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
         {
-            VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
+            VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
+            out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
+            VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderObject = in_ext->shaderObject;
+            out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
+            VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
-            out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
-            out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
+            out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
         {
-            VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
+            VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
-            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
+            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
         {
-            VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAntiLagFeaturesAMD32 *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD;
+            VkPhysicalDeviceShaderSubgroupRotateFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->antiLag = in_ext->antiLag;
+            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
+            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
         {
-            VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM;
+            VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->tileMemoryHeap = in_ext->tileMemoryHeap;
+            out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
         {
-            VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCubicClampFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM;
+            VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->cubicRangeClamp = in_ext->cubicRangeClamp;
+            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
         {
-            VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM;
+            VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->ycbcrDegamma = in_ext->ycbcrDegamma;
+            out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
+            out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
+            out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
         {
-            VkPhysicalDeviceCubicWeightsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM;
+            VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->selectableCubicWeights = in_ext->selectableCubicWeights;
+            out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
         {
-            VkPhysicalDeviceImageProcessing2FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM;
+            VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2;
+            out_ext->shadingRateImage = in_ext->shadingRateImage;
+            out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
         {
-            VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV;
+            VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation;
+            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
+            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
         {
-            VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV;
+            VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet;
-            out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout;
+            out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
         {
-            VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDeviceQueueShaderCoreControlCreateInfoARM32 *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM;
+            VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
             out_ext->pNext = NULL;
-            out_ext->shaderCoreCount = in_ext->shaderCoreCount;
+            out_ext->subpassShading = in_ext->subpassShading;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
         {
-            VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM;
+            VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->schedulingControls = in_ext->schedulingControls;
+            out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
         {
-            VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG;
+            VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization;
+            out_ext->synchronization2 = in_ext->synchronization2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
         {
-            VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM;
+            VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceTensorFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->renderPassStriped = in_ext->renderPassStriped;
+            out_ext->tensorNonPacked = in_ext->tensorNonPacked;
+            out_ext->shaderTensorAccess = in_ext->shaderTensorAccess;
+            out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing;
+            out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing;
+            out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind;
+            out_ext->tensors = in_ext->tensors;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM;
+            VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap;
+            out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
         {
-            VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR;
+            VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence;
+            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderSubgroupRotateFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
+            VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
-            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
+            out_ext->tileMemoryHeap = in_ext->tileMemoryHeap;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderExpectAssumeFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderExpectAssumeFeatures32 *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
+            VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
+            out_ext->tileProperties = in_ext->tileProperties;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderFloatControls2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderFloatControls2Features32 *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
+            VkPhysicalDeviceTileShadingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTileShadingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
-        {
-            VkPhysicalDeviceDynamicRenderingLocalReadFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
-            out_ext->pNext = NULL;
-            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
-        {
-            VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR;
-            out_ext->pNext = NULL;
-            out_ext->shaderQuadControl = in_ext->shaderQuadControl;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
-        {
-            VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV;
-            out_ext->pNext = NULL;
-            out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
-        {
-            VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
-            out_ext->pNext = NULL;
-            out_ext->memoryMapPlaced = in_ext->memoryMapPlaced;
-            out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced;
-            out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
-        {
-            VkPhysicalDeviceShaderBfloat16FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR;
-            out_ext->pNext = NULL;
-            out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type;
-            out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct;
-            out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
-        {
-            VkPhysicalDeviceRawAccessChainsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV;
-            out_ext->pNext = NULL;
-            out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains;
+            out_ext->tileShading = in_ext->tileShading;
+            out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage;
+            out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments;
+            out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments;
+            out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments;
+            out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments;
+            out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments;
+            out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw;
+            out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch;
+            out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile;
+            out_ext->tileShadingApron = in_ext->tileShadingApron;
+            out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron;
+            out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps;
+            out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
         {
-            VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV;
+            VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->commandBufferInheritance = in_ext->commandBufferInheritance;
+            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
         {
-            VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA;
+            VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->imageAlignmentControl = in_ext->imageAlignmentControl;
+            out_ext->transformFeedback = in_ext->transformFeedback;
+            out_ext->geometryStreams = in_ext->geometryStreams;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
         {
-            VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT;
+            VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites;
+            out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts;
+            out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
         {
-            VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR;
+            VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady;
+            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
         {
-            VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV;
+            VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope;
-            out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions;
-            out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions;
-            out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions;
-            out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations;
-            out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing;
-            out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads;
+            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
+            out_ext->variablePointers = in_ext->variablePointers;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
         {
-            VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI;
+            VkPhysicalDeviceVertexAttributeDivisorFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->hdrVivid = in_ext->hdrVivid;
+            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
+            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -21743,145 +21603,285 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
         {
-            VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
+            VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
+            out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
         {
-            VkPhysicalDeviceCooperativeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV;
+            VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->cooperativeVector = in_ext->cooperativeVector;
-            out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining;
+            out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
         {
-            VkPhysicalDeviceTileShadingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTileShadingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM;
+            VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->tileShading = in_ext->tileShading;
-            out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage;
-            out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments;
-            out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments;
-            out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments;
-            out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments;
-            out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments;
-            out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw;
-            out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch;
-            out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile;
-            out_ext->tileShadingApron = in_ext->tileShadingApron;
-            out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron;
-            out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps;
-            out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing;
+            out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
         {
-            VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE;
+            VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR;
             out_ext->pNext = NULL;
+            out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
         {
-            VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFormatPackFeaturesARM32 *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM;
+            VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->formatPack = in_ext->formatPack;
+            out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
         {
-            VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceTensorFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM;
+            VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->tensorNonPacked = in_ext->tensorNonPacked;
-            out_ext->shaderTensorAccess = in_ext->shaderTensorAccess;
-            out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing;
-            out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing;
-            out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind;
-            out_ext->tensors = in_ext->tensors;
+            out_ext->videoMaintenance1 = in_ext->videoMaintenance1;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
         {
-            VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM;
+            VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors;
+            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
+            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
+            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
+            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
+            out_ext->multiview = in_ext->multiview;
+            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
+            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
+            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
+            out_ext->variablePointers = in_ext->variablePointers;
+            out_ext->protectedMemory = in_ext->protectedMemory;
+            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
+            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
         {
-            VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT;
+            VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderFloat8 = in_ext->shaderFloat8;
-            out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix;
+            out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
+            out_ext->drawIndirectCount = in_ext->drawIndirectCount;
+            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
+            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
+            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
+            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
+            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
+            out_ext->shaderFloat16 = in_ext->shaderFloat16;
+            out_ext->shaderInt8 = in_ext->shaderInt8;
+            out_ext->descriptorIndexing = in_ext->descriptorIndexing;
+            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
+            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
+            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
+            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
+            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
+            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
+            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
+            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
+            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
+            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
+            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
+            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
+            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
+            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
+            out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
+            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
+            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
+            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
+            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
+            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
+            out_ext->hostQueryReset = in_ext->hostQueryReset;
+            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
+            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
+            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
+            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
+            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
+            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
+            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
+            out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
+            out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
+            out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
         {
-            VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDataGraphFeaturesARM32 *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM;
+            VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->dataGraph = in_ext->dataGraph;
-            out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind;
-            out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants;
-            out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer;
-            out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule;
+            out_ext->robustImageAccess = in_ext->robustImageAccess;
+            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
+            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
+            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
+            out_ext->privateData = in_ext->privateData;
+            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
+            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
+            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
+            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
+            out_ext->synchronization2 = in_ext->synchronization2;
+            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
+            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
+            out_ext->dynamicRendering = in_ext->dynamicRendering;
+            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
+            out_ext->maintenance4 = in_ext->maintenance4;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
         {
-            VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC;
+            VkPhysicalDeviceVulkan14Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkan14Features32 *in_ext = (const VkPhysicalDeviceVulkan14Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode;
+            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
+            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
+            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
+            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
+            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
+            out_ext->rectangularLines = in_ext->rectangularLines;
+            out_ext->bresenhamLines = in_ext->bresenhamLines;
+            out_ext->smoothLines = in_ext->smoothLines;
+            out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
+            out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
+            out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
+            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
+            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
+            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
+            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
+            out_ext->maintenance5 = in_ext->maintenance5;
+            out_ext->maintenance6 = in_ext->maintenance6;
+            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
+            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
+            out_ext->hostImageCopy = in_ext->hostImageCopy;
+            out_ext->pushDescriptor = in_ext->pushDescriptor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
         {
-            VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR;
+            VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers;
+            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
+            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
+            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
+        {
+            VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
+            out_ext->pNext = NULL;
+            out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
+            out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
+            out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
+            out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
+        {
+            VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
+            out_ext->pNext = NULL;
+            out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
+        {
+            VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM;
+            out_ext->pNext = NULL;
+            out_ext->ycbcrDegamma = in_ext->ycbcrDegamma;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
+        {
+            VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
+            out_ext->pNext = NULL;
+            out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
+        {
+            VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT;
+            out_ext->pNext = NULL;
+            out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
+        {
+            VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
+            out_ext->pNext = NULL;
+            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22092,25 +22092,26 @@ static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
         {
-            VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCreateFlags2CreateInfo *in_ext = (const VkPipelineCreateFlags2CreateInfo *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
+            VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
+            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
+            out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
+            out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
         {
-            VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineBinaryInfoKHR *in_ext = (const VkPipelineBinaryInfoKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR;
+            VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->binaryCount = in_ext->binaryCount;
-            out_ext->pPipelineBinaries = in_ext->pPipelineBinaries;
+            out_ext->flags = in_ext->flags;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22129,27 +22130,36 @@ static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
         {
-            VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
+            VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineBinaryInfoKHR *in_ext = (const VkPipelineBinaryInfoKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->discardRectangleMode = in_ext->discardRectangleMode;
-            out_ext->discardRectangleCount = in_ext->discardRectangleCount;
-            out_ext->pDiscardRectangles = in_ext->pDiscardRectangles;
+            out_ext->binaryCount = in_ext->binaryCount;
+            out_ext->pPipelineBinaries = in_ext->pPipelineBinaries;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
         {
-            VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
+            VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
             out_ext->pNext = NULL;
-            out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
+            out_ext->compilerControlFlags = in_ext->compilerControlFlags;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
+        {
+            VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCreateFlags2CreateInfo *in_ext = (const VkPipelineCreateFlags2CreateInfo *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
+            out_ext->pNext = NULL;
+            out_ext->flags = in_ext->flags;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22167,25 +22177,40 @@ static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
+        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
         {
-            VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
+            VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->compilerControlFlags = in_ext->compilerControlFlags;
-            out_header->pNext = (void *)out_ext;
+            out_ext->flags = in_ext->flags;
+            out_ext->discardRectangleMode = in_ext->discardRectangleMode;
+            out_ext->discardRectangleCount = in_ext->discardRectangleCount;
+            out_ext->pDiscardRectangles = in_ext->pDiscardRectangles;
+            out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE:
         {
-            VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
+            VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE;
             out_ext->pNext = NULL;
-            out_ext->libraryCount = in_ext->libraryCount;
-            out_ext->pLibraries = in_ext->pLibraries;
+            out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
+        {
+            VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
+            out_ext->pNext = NULL;
+            out_ext->shadingRateType = in_ext->shadingRateType;
+            out_ext->shadingRate = in_ext->shadingRate;
+            memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22202,15 +22227,14 @@ static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
         {
-            VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
+            VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->shadingRateType = in_ext->shadingRateType;
-            out_ext->shadingRate = in_ext->shadingRate;
-            memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
+            out_ext->libraryCount = in_ext->libraryCount;
+            out_ext->pLibraries = in_ext->pLibraries;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22230,26 +22254,13 @@ static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
-        {
-            VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
-            out_ext->pNext = NULL;
-            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
-            out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
-            out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
         {
-            VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
+            VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
+            out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22294,17 +22305,6 @@ static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE:
-        {
-            VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE;
-            out_ext->pNext = NULL;
-            out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -22499,28 +22499,38 @@ static void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struct conve
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
         {
-            VkPipelineViewportWScalingStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineViewportWScalingStateCreateInfoNV32 *in_ext = (const VkPipelineViewportWScalingStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV;
+            VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *in_ext = (const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable;
-            out_ext->viewportCount = in_ext->viewportCount;
-            out_ext->pViewportWScalings = UlongToPtr(in_ext->pViewportWScalings);
+            out_ext->sampleOrderType = in_ext->sampleOrderType;
+            out_ext->customSampleOrderCount = in_ext->customSampleOrderCount;
+            out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(in_ext->pCustomSampleOrders), in_ext->customSampleOrderCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
         {
-            VkPipelineViewportSwizzleStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineViewportSwizzleStateCreateInfoNV32 *in_ext = (const VkPipelineViewportSwizzleStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV;
+            VkPipelineViewportDepthClampControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineViewportDepthClampControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClampControlCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->viewportCount = in_ext->viewportCount;
-            out_ext->pViewportSwizzles = UlongToPtr(in_ext->pViewportSwizzles);
+            out_ext->depthClampMode = in_ext->depthClampMode;
+            out_ext->pDepthClampRange = UlongToPtr(in_ext->pDepthClampRange);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
+        {
+            VkPipelineViewportDepthClipControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineViewportDepthClipControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClipControlCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->negativeOneToOne = in_ext->negativeOneToOne;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22550,38 +22560,28 @@ static void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struct conve
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
-        {
-            VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *in_ext = (const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV;
-            out_ext->pNext = NULL;
-            out_ext->sampleOrderType = in_ext->sampleOrderType;
-            out_ext->customSampleOrderCount = in_ext->customSampleOrderCount;
-            out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(in_ext->pCustomSampleOrders), in_ext->customSampleOrderCount);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
         {
-            VkPipelineViewportDepthClipControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineViewportDepthClipControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClipControlCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT;
+            VkPipelineViewportSwizzleStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineViewportSwizzleStateCreateInfoNV32 *in_ext = (const VkPipelineViewportSwizzleStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->negativeOneToOne = in_ext->negativeOneToOne;
+            out_ext->flags = in_ext->flags;
+            out_ext->viewportCount = in_ext->viewportCount;
+            out_ext->pViewportSwizzles = UlongToPtr(in_ext->pViewportSwizzles);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
         {
-            VkPipelineViewportDepthClampControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineViewportDepthClampControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClampControlCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT;
+            VkPipelineViewportWScalingStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineViewportWScalingStateCreateInfoNV32 *in_ext = (const VkPipelineViewportWScalingStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->depthClampMode = in_ext->depthClampMode;
-            out_ext->pDepthClampRange = UlongToPtr(in_ext->pDepthClampRange);
+            out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable;
+            out_ext->viewportCount = in_ext->viewportCount;
+            out_ext->pViewportWScalings = UlongToPtr(in_ext->pViewportWScalings);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22634,13 +22634,14 @@ static void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+        case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
         {
-            VkPipelineRasterizationStateRasterizationOrderAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRasterizationStateRasterizationOrderAMD32 *in_ext = (const VkPipelineRasterizationStateRasterizationOrderAMD32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD;
+            VkDepthBiasRepresentationInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDepthBiasRepresentationInfoEXT32 *in_ext = (const VkDepthBiasRepresentationInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->rasterizationOrder = in_ext->rasterizationOrder;
+            out_ext->depthBiasRepresentation = in_ext->depthBiasRepresentation;
+            out_ext->depthBiasExact = in_ext->depthBiasExact;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22658,18 +22659,6 @@ static void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
-        {
-            VkPipelineRasterizationStateStreamCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRasterizationStateStreamCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationStateStreamCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->rasterizationStream = in_ext->rasterizationStream;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
         {
             VkPipelineRasterizationDepthClipStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -22707,14 +22696,25 @@ static void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
         {
-            VkDepthBiasRepresentationInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDepthBiasRepresentationInfoEXT32 *in_ext = (const VkDepthBiasRepresentationInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT;
+            VkPipelineRasterizationStateRasterizationOrderAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRasterizationStateRasterizationOrderAMD32 *in_ext = (const VkPipelineRasterizationStateRasterizationOrderAMD32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD;
             out_ext->pNext = NULL;
-            out_ext->depthBiasRepresentation = in_ext->depthBiasRepresentation;
-            out_ext->depthBiasExact = in_ext->depthBiasExact;
+            out_ext->rasterizationOrder = in_ext->rasterizationOrder;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
+        {
+            VkPipelineRasterizationStateStreamCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRasterizationStateStreamCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationStateStreamCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->flags = in_ext->flags;
+            out_ext->rasterizationStream = in_ext->rasterizationStream;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -22763,31 +22763,6 @@ static void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(struct co
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
-        {
-            VkPipelineCoverageToColorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCoverageToColorStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageToColorStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV;
-            out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->coverageToColorEnable = in_ext->coverageToColorEnable;
-            out_ext->coverageToColorLocation = in_ext->coverageToColorLocation;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
-        {
-            VkPipelineSampleLocationsStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineSampleLocationsStateCreateInfoEXT32 *in_ext = (const VkPipelineSampleLocationsStateCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->sampleLocationsEnable = in_ext->sampleLocationsEnable;
-            convert_VkSampleLocationsInfoEXT_win32_to_host(&in_ext->sampleLocationsInfo, &out_ext->sampleLocationsInfo);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
         {
             VkPipelineCoverageModulationStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -22815,6 +22790,31 @@ static void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(struct co
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+        {
+            VkPipelineCoverageToColorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCoverageToColorStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageToColorStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV;
+            out_ext->pNext = NULL;
+            out_ext->flags = in_ext->flags;
+            out_ext->coverageToColorEnable = in_ext->coverageToColorEnable;
+            out_ext->coverageToColorLocation = in_ext->coverageToColorLocation;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+        {
+            VkPipelineSampleLocationsStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineSampleLocationsStateCreateInfoEXT32 *in_ext = (const VkPipelineSampleLocationsStateCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->sampleLocationsEnable = in_ext->sampleLocationsEnable;
+            convert_VkSampleLocationsInfoEXT_win32_to_host(&in_ext->sampleLocationsInfo, &out_ext->sampleLocationsInfo);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -23032,25 +23032,26 @@ static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
         {
-            VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCreateFlags2CreateInfo32 *in_ext = (const VkPipelineCreateFlags2CreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
+            VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
+            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
+            out_ext->pColorAttachmentSamples = UlongToPtr(in_ext->pColorAttachmentSamples);
+            out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
         {
-            VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineBinaryInfoKHR32 *in_ext = (const VkPipelineBinaryInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR;
+            VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkGraphicsPipelineLibraryCreateInfoEXT32 *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->binaryCount = in_ext->binaryCount;
-            out_ext->pPipelineBinaries = UlongToPtr(in_ext->pPipelineBinaries);
+            out_ext->flags = in_ext->flags;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23069,27 +23070,36 @@ static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
         {
-            VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineDiscardRectangleStateCreateInfoEXT32 *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
+            VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineBinaryInfoKHR32 *in_ext = (const VkPipelineBinaryInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->discardRectangleMode = in_ext->discardRectangleMode;
-            out_ext->discardRectangleCount = in_ext->discardRectangleCount;
-            out_ext->pDiscardRectangles = UlongToPtr(in_ext->pDiscardRectangles);
+            out_ext->binaryCount = in_ext->binaryCount;
+            out_ext->pPipelineBinaries = UlongToPtr(in_ext->pPipelineBinaries);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
         {
-            VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
+            VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
             out_ext->pNext = NULL;
-            out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
+            out_ext->compilerControlFlags = in_ext->compilerControlFlags;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
+        {
+            VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCreateFlags2CreateInfo32 *in_ext = (const VkPipelineCreateFlags2CreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
+            out_ext->pNext = NULL;
+            out_ext->flags = in_ext->flags;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23107,25 +23117,40 @@ static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
+        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
         {
-            VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
+            VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineDiscardRectangleStateCreateInfoEXT32 *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->compilerControlFlags = in_ext->compilerControlFlags;
+            out_ext->flags = in_ext->flags;
+            out_ext->discardRectangleMode = in_ext->discardRectangleMode;
+            out_ext->discardRectangleCount = in_ext->discardRectangleCount;
+            out_ext->pDiscardRectangles = UlongToPtr(in_ext->pDiscardRectangles);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE:
         {
-            VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineLibraryCreateInfoKHR32 *in_ext = (const VkPipelineLibraryCreateInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
+            VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32 *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE;
             out_ext->pNext = NULL;
-            out_ext->libraryCount = in_ext->libraryCount;
-            out_ext->pLibraries = UlongToPtr(in_ext->pLibraries);
+            out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
+        {
+            VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
+            out_ext->pNext = NULL;
+            out_ext->shadingRateType = in_ext->shadingRateType;
+            out_ext->shadingRate = in_ext->shadingRate;
+            memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23142,15 +23167,14 @@ static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
         {
-            VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
+            VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineLibraryCreateInfoKHR32 *in_ext = (const VkPipelineLibraryCreateInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->shadingRateType = in_ext->shadingRateType;
-            out_ext->shadingRate = in_ext->shadingRate;
-            memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
+            out_ext->libraryCount = in_ext->libraryCount;
+            out_ext->pLibraries = UlongToPtr(in_ext->pLibraries);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23170,26 +23194,13 @@ static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
-        {
-            VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
-            out_ext->pNext = NULL;
-            out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
-            out_ext->pColorAttachmentSamples = UlongToPtr(in_ext->pColorAttachmentSamples);
-            out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
         {
-            VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkGraphicsPipelineLibraryCreateInfoEXT32 *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
+            VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
+            out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23234,17 +23245,6 @@ static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE:
-        {
-            VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32 *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE;
-            out_ext->pNext = NULL;
-            out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -23358,13 +23358,26 @@ static void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
         {
-            VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImageSwapchainCreateInfoKHR *in_ext = (const VkImageSwapchainCreateInfoKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
+            VkImageAlignmentControlCreateInfoMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImageAlignmentControlCreateInfoMESA *in_ext = (const VkImageAlignmentControlCreateInfoMESA *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA;
             out_ext->pNext = NULL;
-            out_ext->swapchain = in_ext->swapchain ? vulkan_swapchain_from_handle(in_ext->swapchain)->host.swapchain : 0;
+            out_ext->maximumRequestedAlignment = in_ext->maximumRequestedAlignment;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
+        {
+            VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImageCompressionControlEXT *in_ext = (const VkImageCompressionControlEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
+            out_ext->pNext = NULL;
+            out_ext->flags = in_ext->flags;
+            out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
+            out_ext->pFixedRateFlags = in_ext->pFixedRateFlags;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23392,14 +23405,13 @@ static void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
+        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
         {
-            VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoProfileListInfoKHR *in_ext = (const VkVideoProfileListInfoKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
+            VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImageSwapchainCreateInfoKHR *in_ext = (const VkImageSwapchainCreateInfoKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->profileCount = in_ext->profileCount;
-            out_ext->pProfiles = in_ext->pProfiles;
+            out_ext->swapchain = in_ext->swapchain ? vulkan_swapchain_from_handle(in_ext->swapchain)->host.swapchain : 0;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23415,19 +23427,6 @@ static void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
-        {
-            VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImageCompressionControlEXT *in_ext = (const VkImageCompressionControlEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
-            out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
-            out_ext->pFixedRateFlags = in_ext->pFixedRateFlags;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
         {
             VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -23439,13 +23438,14 @@ static void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
         {
-            VkImageAlignmentControlCreateInfoMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImageAlignmentControlCreateInfoMESA *in_ext = (const VkImageAlignmentControlCreateInfoMESA *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA;
+            VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoProfileListInfoKHR *in_ext = (const VkVideoProfileListInfoKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->maximumRequestedAlignment = in_ext->maximumRequestedAlignment;
+            out_ext->profileCount = in_ext->profileCount;
+            out_ext->pProfiles = in_ext->pProfiles;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23507,13 +23507,26 @@ static void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
         {
-            VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImageSwapchainCreateInfoKHR32 *in_ext = (const VkImageSwapchainCreateInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
+            VkImageAlignmentControlCreateInfoMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImageAlignmentControlCreateInfoMESA32 *in_ext = (const VkImageAlignmentControlCreateInfoMESA32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA;
             out_ext->pNext = NULL;
-            out_ext->swapchain = in_ext->swapchain ? vulkan_swapchain_from_handle(in_ext->swapchain)->host.swapchain : 0;
+            out_ext->maximumRequestedAlignment = in_ext->maximumRequestedAlignment;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
+        {
+            VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
+            out_ext->pNext = NULL;
+            out_ext->flags = in_ext->flags;
+            out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
+            out_ext->pFixedRateFlags = UlongToPtr(in_ext->pFixedRateFlags);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23541,14 +23554,13 @@ static void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
+        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
         {
-            VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoProfileListInfoKHR32 *in_ext = (const VkVideoProfileListInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
+            VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImageSwapchainCreateInfoKHR32 *in_ext = (const VkImageSwapchainCreateInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->profileCount = in_ext->profileCount;
-            out_ext->pProfiles = convert_VkVideoProfileInfoKHR_array_win32_to_host(ctx, (const VkVideoProfileInfoKHR32 *)UlongToPtr(in_ext->pProfiles), in_ext->profileCount);
+            out_ext->swapchain = in_ext->swapchain ? vulkan_swapchain_from_handle(in_ext->swapchain)->host.swapchain : 0;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23564,19 +23576,6 @@ static void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
-        {
-            VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
-            out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
-            out_ext->pFixedRateFlags = UlongToPtr(in_ext->pFixedRateFlags);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
         {
             VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -23588,13 +23587,14 @@ static void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
         {
-            VkImageAlignmentControlCreateInfoMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImageAlignmentControlCreateInfoMESA32 *in_ext = (const VkImageAlignmentControlCreateInfoMESA32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA;
+            VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoProfileListInfoKHR32 *in_ext = (const VkVideoProfileListInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->maximumRequestedAlignment = in_ext->maximumRequestedAlignment;
+            out_ext->profileCount = in_ext->profileCount;
+            out_ext->pProfiles = convert_VkVideoProfileInfoKHR_array_win32_to_host(ctx, (const VkVideoProfileInfoKHR32 *)UlongToPtr(in_ext->pProfiles), in_ext->profileCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23626,82 +23626,82 @@ static void convert_VkImageViewCreateInfo_win32_to_host(struct conversion_contex
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
         {
-            VkImageViewUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImageViewUsageCreateInfo32 *in_ext = (const VkImageViewUsageCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
-            out_ext->pNext = NULL;
-            out_ext->usage = in_ext->usage;
+            VkImageViewASTCDecodeModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImageViewASTCDecodeModeEXT32 *in_ext = (const VkImageViewASTCDecodeModeEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT;
+            out_ext->pNext = NULL;
+            out_ext->decodeMode = in_ext->decodeMode;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
         {
-            VkImageViewSlicedCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImageViewSlicedCreateInfoEXT32 *in_ext = (const VkImageViewSlicedCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT;
+            VkImageViewMinLodCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImageViewMinLodCreateInfoEXT32 *in_ext = (const VkImageViewMinLodCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->sliceOffset = in_ext->sliceOffset;
-            out_ext->sliceCount = in_ext->sliceCount;
+            out_ext->minLod = in_ext->minLod;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
         {
-            VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
+            VkImageViewSampleWeightCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImageViewSampleWeightCreateInfoQCOM32 *in_ext = (const VkImageViewSampleWeightCreateInfoQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM;
             out_ext->pNext = NULL;
-            out_ext->conversion = in_ext->conversion;
+            out_ext->filterCenter = in_ext->filterCenter;
+            out_ext->filterSize = in_ext->filterSize;
+            out_ext->numPhases = in_ext->numPhases;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
         {
-            VkImageViewASTCDecodeModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImageViewASTCDecodeModeEXT32 *in_ext = (const VkImageViewASTCDecodeModeEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT;
+            VkImageViewSlicedCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImageViewSlicedCreateInfoEXT32 *in_ext = (const VkImageViewSlicedCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->decodeMode = in_ext->decodeMode;
+            out_ext->sliceOffset = in_ext->sliceOffset;
+            out_ext->sliceCount = in_ext->sliceCount;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
         {
-            VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
+            VkImageViewUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImageViewUsageCreateInfo32 *in_ext = (const VkImageViewUsageCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData);
+            out_ext->usage = in_ext->usage;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
         {
-            VkImageViewMinLodCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImageViewMinLodCreateInfoEXT32 *in_ext = (const VkImageViewMinLodCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT;
+            VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->minLod = in_ext->minLod;
+            out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
         {
-            VkImageViewSampleWeightCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImageViewSampleWeightCreateInfoQCOM32 *in_ext = (const VkImageViewSampleWeightCreateInfoQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM;
+            VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
             out_ext->pNext = NULL;
-            out_ext->filterCenter = in_ext->filterCenter;
-            out_ext->filterSize = in_ext->filterSize;
-            out_ext->numPhases = in_ext->numPhases;
+            out_ext->conversion = in_ext->conversion;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23999,14 +23999,29 @@ static void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
         {
-            VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkValidationFlagsEXT *in_ext = (const VkValidationFlagsEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
+            VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDebugUtilsMessengerCreateInfoEXT *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
-            out_ext->pDisabledValidationChecks = in_ext->pDisabledValidationChecks;
+            out_ext->flags = in_ext->flags;
+            out_ext->messageSeverity = in_ext->messageSeverity;
+            out_ext->messageType = in_ext->messageType;
+            out_ext->pfnUserCallback = in_ext->pfnUserCallback;
+            out_ext->pUserData = in_ext->pUserData;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
+        {
+            VkLayerSettingsCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkLayerSettingsCreateInfoEXT *in_ext = (const VkLayerSettingsCreateInfoEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->settingCount = in_ext->settingCount;
+            out_ext->pSettings = in_ext->pSettings;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -24025,29 +24040,14 @@ static void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
-        {
-            VkLayerSettingsCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkLayerSettingsCreateInfoEXT *in_ext = (const VkLayerSettingsCreateInfoEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->settingCount = in_ext->settingCount;
-            out_ext->pSettings = in_ext->pSettings;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
         {
-            VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDebugUtilsMessengerCreateInfoEXT *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
+            VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkValidationFlagsEXT *in_ext = (const VkValidationFlagsEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->messageSeverity = in_ext->messageSeverity;
-            out_ext->messageType = in_ext->messageType;
-            out_ext->pfnUserCallback = in_ext->pfnUserCallback;
-            out_ext->pUserData = in_ext->pUserData;
+            out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
+            out_ext->pDisabledValidationChecks = in_ext->pDisabledValidationChecks;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -24153,14 +24153,29 @@ static void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
         {
-            VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkValidationFlagsEXT32 *in_ext = (const VkValidationFlagsEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
+            VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkDebugUtilsMessengerCreateInfoEXT32 *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
-            out_ext->pDisabledValidationChecks = UlongToPtr(in_ext->pDisabledValidationChecks);
+            out_ext->flags = in_ext->flags;
+            out_ext->messageSeverity = in_ext->messageSeverity;
+            out_ext->messageType = in_ext->messageType;
+            out_ext->pfnUserCallback = (PFN_vkDebugUtilsMessengerCallbackEXT)UlongToPtr(in_ext->pfnUserCallback);
+            out_ext->pUserData = UlongToPtr(in_ext->pUserData);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
+        {
+            VkLayerSettingsCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkLayerSettingsCreateInfoEXT32 *in_ext = (const VkLayerSettingsCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->settingCount = in_ext->settingCount;
+            out_ext->pSettings = convert_VkLayerSettingEXT_array_win32_to_host(ctx, (const VkLayerSettingEXT32 *)UlongToPtr(in_ext->pSettings), in_ext->settingCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -24179,29 +24194,14 @@ static void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
-        {
-            VkLayerSettingsCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkLayerSettingsCreateInfoEXT32 *in_ext = (const VkLayerSettingsCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->settingCount = in_ext->settingCount;
-            out_ext->pSettings = convert_VkLayerSettingEXT_array_win32_to_host(ctx, (const VkLayerSettingEXT32 *)UlongToPtr(in_ext->pSettings), in_ext->settingCount);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
         {
-            VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkDebugUtilsMessengerCreateInfoEXT32 *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
+            VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkValidationFlagsEXT32 *in_ext = (const VkValidationFlagsEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->messageSeverity = in_ext->messageSeverity;
-            out_ext->messageType = in_ext->messageType;
-            out_ext->pfnUserCallback = (PFN_vkDebugUtilsMessengerCallbackEXT)UlongToPtr(in_ext->pfnUserCallback);
-            out_ext->pUserData = UlongToPtr(in_ext->pUserData);
+            out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
+            out_ext->pDisabledValidationChecks = UlongToPtr(in_ext->pDisabledValidationChecks);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -24489,27 +24489,25 @@ static void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR:
         {
-            VkVideoProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoProfileInfoKHR32 *in_ext = (const VkVideoProfileInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR;
+            VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32 *in_ext = (const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->videoCodecOperation = in_ext->videoCodecOperation;
-            out_ext->chromaSubsampling = in_ext->chromaSubsampling;
-            out_ext->lumaBitDepth = in_ext->lumaBitDepth;
-            out_ext->chromaBitDepth = in_ext->chromaBitDepth;
+            out_ext->encodeFeedbackFlags = in_ext->encodeFeedbackFlags;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
         {
-            VkVideoDecodeUsageInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoDecodeUsageInfoKHR32 *in_ext = (const VkVideoDecodeUsageInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR;
+            VkVideoDecodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoDecodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoDecodeAV1ProfileInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->videoUsageHints = in_ext->videoUsageHints;
+            out_ext->stdProfile = in_ext->stdProfile;
+            out_ext->filmGrainSupport = in_ext->filmGrainSupport;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -24526,6 +24524,17 @@ static void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
+        {
+            VkVideoDecodeUsageInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoDecodeUsageInfoKHR32 *in_ext = (const VkVideoDecodeUsageInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR;
+            out_ext->pNext = NULL;
+            out_ext->videoUsageHints = in_ext->videoUsageHints;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
         {
             VkVideoDecodeVP9ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -24537,14 +24546,24 @@ static void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
         {
-            VkVideoDecodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoDecodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoDecodeAV1ProfileInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR;
+            VkVideoEncodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoEncodeAV1ProfileInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR;
             out_ext->pNext = NULL;
             out_ext->stdProfile = in_ext->stdProfile;
-            out_ext->filmGrainSupport = in_ext->filmGrainSupport;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR:
+        {
+            VkVideoEncodeH264ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeH264ProfileInfoKHR32 *in_ext = (const VkVideoEncodeH264ProfileInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR;
+            out_ext->pNext = NULL;
+            out_ext->stdProfileIdc = in_ext->stdProfileIdc;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -24562,35 +24581,16 @@ static void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
         {
-            VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32 *in_ext = (const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR;
+            VkVideoProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoProfileInfoKHR32 *in_ext = (const VkVideoProfileInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->encodeFeedbackFlags = in_ext->encodeFeedbackFlags;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR:
-        {
-            VkVideoEncodeH264ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeH264ProfileInfoKHR32 *in_ext = (const VkVideoEncodeH264ProfileInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->stdProfileIdc = in_ext->stdProfileIdc;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
-        {
-            VkVideoEncodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoEncodeAV1ProfileInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->stdProfile = in_ext->stdProfile;
+            out_ext->videoCodecOperation = in_ext->videoCodecOperation;
+            out_ext->chromaSubsampling = in_ext->chromaSubsampling;
+            out_ext->lumaBitDepth = in_ext->lumaBitDepth;
+            out_ext->chromaBitDepth = in_ext->chromaBitDepth;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -24756,17 +24756,6 @@ static void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conve
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
-        {
-            VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineCreateFlags2CreateInfo32 *in_ext = (const VkPipelineCreateFlags2CreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
-            out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
         {
             VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -24779,13 +24768,13 @@ static void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conve
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
         {
-            VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32 *in_ext = (const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV;
+            VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineCreateFlags2CreateInfo32 *in_ext = (const VkPipelineCreateFlags2CreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->allowClusterAccelerationStructure = in_ext->allowClusterAccelerationStructure;
+            out_ext->flags = in_ext->flags;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -24817,6 +24806,17 @@ static void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conve
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
+        {
+            VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32 *in_ext = (const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV;
+            out_ext->pNext = NULL;
+            out_ext->allowClusterAccelerationStructure = in_ext->allowClusterAccelerationStructure;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -25111,18 +25111,13 @@ static void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_conte
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
         {
-            VkRenderPassMultiviewCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRenderPassMultiviewCreateInfo32 *in_ext = (const VkRenderPassMultiviewCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
+            VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->subpassCount = in_ext->subpassCount;
-            out_ext->pViewMasks = UlongToPtr(in_ext->pViewMasks);
-            out_ext->dependencyCount = in_ext->dependencyCount;
-            out_ext->pViewOffsets = UlongToPtr(in_ext->pViewOffsets);
-            out_ext->correlationMaskCount = in_ext->correlationMaskCount;
-            out_ext->pCorrelationMasks = UlongToPtr(in_ext->pCorrelationMasks);
+            out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -25139,24 +25134,18 @@ static void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_conte
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
-        {
-            VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
+        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
         {
-            VkTileMemorySizeInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkTileMemorySizeInfoQCOM32 *in_ext = (const VkTileMemorySizeInfoQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM;
+            VkRenderPassMultiviewCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRenderPassMultiviewCreateInfo32 *in_ext = (const VkRenderPassMultiviewCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->size = in_ext->size;
+            out_ext->subpassCount = in_ext->subpassCount;
+            out_ext->pViewMasks = UlongToPtr(in_ext->pViewMasks);
+            out_ext->dependencyCount = in_ext->dependencyCount;
+            out_ext->pViewOffsets = UlongToPtr(in_ext->pViewOffsets);
+            out_ext->correlationMaskCount = in_ext->correlationMaskCount;
+            out_ext->pCorrelationMasks = UlongToPtr(in_ext->pCorrelationMasks);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -25173,6 +25162,17 @@ static void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_conte
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
+        {
+            VkTileMemorySizeInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkTileMemorySizeInfoQCOM32 *in_ext = (const VkTileMemorySizeInfoQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM;
+            out_ext->pNext = NULL;
+            out_ext->size = in_ext->size;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -25314,19 +25314,6 @@ static void convert_VkSubpassDescription2_win32_to_host(struct conversion_contex
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
-        {
-            VkSubpassDescriptionDepthStencilResolve *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkSubpassDescriptionDepthStencilResolve32 *in_ext = (const VkSubpassDescriptionDepthStencilResolve32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
-            out_ext->pNext = NULL;
-            out_ext->depthResolveMode = in_ext->depthResolveMode;
-            out_ext->stencilResolveMode = in_ext->stencilResolveMode;
-            out_ext->pDepthStencilResolveAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pDepthStencilResolveAttachment), 1);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
         {
             VkFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -25373,6 +25360,19 @@ static void convert_VkSubpassDescription2_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
+        {
+            VkSubpassDescriptionDepthStencilResolve *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkSubpassDescriptionDepthStencilResolve32 *in_ext = (const VkSubpassDescriptionDepthStencilResolve32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
+            out_ext->pNext = NULL;
+            out_ext->depthResolveMode = in_ext->depthResolveMode;
+            out_ext->stencilResolveMode = in_ext->stencilResolveMode;
+            out_ext->pDepthStencilResolveAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pDepthStencilResolveAttachment), 1);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -25490,17 +25490,6 @@ static void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_cont
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
-        {
-            VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
         {
             VkRenderPassCreationControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -25523,13 +25512,13 @@ static void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_cont
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
+        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
         {
-            VkTileMemorySizeInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkTileMemorySizeInfoQCOM32 *in_ext = (const VkTileMemorySizeInfoQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM;
+            VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->size = in_ext->size;
+            out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -25546,6 +25535,17 @@ static void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_cont
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
+        {
+            VkTileMemorySizeInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkTileMemorySizeInfoQCOM32 *in_ext = (const VkTileMemorySizeInfoQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM;
+            out_ext->pNext = NULL;
+            out_ext->size = in_ext->size;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -25583,36 +25583,25 @@ static void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
-        {
-            VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
-            out_ext->pNext = NULL;
-            out_ext->conversion = in_ext->conversion;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
         {
-            VkSamplerReductionModeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkSamplerReductionModeCreateInfo32 *in_ext = (const VkSamplerReductionModeCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
+            VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->reductionMode = in_ext->reductionMode;
+            out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM:
         {
-            VkSamplerCustomBorderColorCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkSamplerCustomBorderColorCreateInfoEXT32 *in_ext = (const VkSamplerCustomBorderColorCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
+            VkSamplerBlockMatchWindowCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkSamplerBlockMatchWindowCreateInfoQCOM32 *in_ext = (const VkSamplerBlockMatchWindowCreateInfoQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM;
             out_ext->pNext = NULL;
-            out_ext->customBorderColor = in_ext->customBorderColor;
-            out_ext->format = in_ext->format;
+            out_ext->windowExtent = in_ext->windowExtent;
+            out_ext->windowCompareMode = in_ext->windowCompareMode;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -25629,36 +25618,47 @@ static void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM:
         {
-            VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
+            VkSamplerCubicWeightsCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkSamplerCubicWeightsCreateInfoQCOM32 *in_ext = (const VkSamplerCubicWeightsCreateInfoQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM;
             out_ext->pNext = NULL;
-            out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData);
+            out_ext->cubicWeights = in_ext->cubicWeights;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM:
+        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
         {
-            VkSamplerCubicWeightsCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkSamplerCubicWeightsCreateInfoQCOM32 *in_ext = (const VkSamplerCubicWeightsCreateInfoQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM;
+            VkSamplerCustomBorderColorCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkSamplerCustomBorderColorCreateInfoEXT32 *in_ext = (const VkSamplerCustomBorderColorCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->cubicWeights = in_ext->cubicWeights;
+            out_ext->customBorderColor = in_ext->customBorderColor;
+            out_ext->format = in_ext->format;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM:
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
         {
-            VkSamplerBlockMatchWindowCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkSamplerBlockMatchWindowCreateInfoQCOM32 *in_ext = (const VkSamplerBlockMatchWindowCreateInfoQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM;
+            VkSamplerReductionModeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkSamplerReductionModeCreateInfo32 *in_ext = (const VkSamplerReductionModeCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->windowExtent = in_ext->windowExtent;
-            out_ext->windowCompareMode = in_ext->windowCompareMode;
+            out_ext->reductionMode = in_ext->reductionMode;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+        {
+            VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
+            out_ext->pNext = NULL;
+            out_ext->conversion = in_ext->conversion;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -25737,25 +25737,25 @@ static void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
         {
-            VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
+            VkQueryLowLatencySupportNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkQueryLowLatencySupportNV32 *in_ext = (const VkQueryLowLatencySupportNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV;
             out_ext->pNext = NULL;
-            out_ext->semaphoreType = in_ext->semaphoreType;
-            out_ext->initialValue = in_ext->initialValue;
+            out_ext->pQueriedLowLatencyData = UlongToPtr(in_ext->pQueriedLowLatencyData);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
+        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
         {
-            VkQueryLowLatencySupportNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkQueryLowLatencySupportNV32 *in_ext = (const VkQueryLowLatencySupportNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV;
+            VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->pQueriedLowLatencyData = UlongToPtr(in_ext->pQueriedLowLatencyData);
+            out_ext->semaphoreType = in_ext->semaphoreType;
+            out_ext->initialValue = in_ext->initialValue;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -25784,7 +25784,18 @@ static void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_con
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+        {
+            VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->validationCache = in_ext->validationCache;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
         {
             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
             const VkValidationFeaturesEXT32 *in_ext = (const VkValidationFeaturesEXT32 *)in_header;
@@ -25798,17 +25809,6 @@ static void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_con
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
-        {
-            VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->validationCache = in_ext->validationCache;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -25842,6 +25842,17 @@ static void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion_contex
     {
         switch (in_header->sType)
         {
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
+        {
+            VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
+            out_ext->pNext = NULL;
+            out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
         {
             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -25856,17 +25867,6 @@ static void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
-        {
-            VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
-            out_ext->pNext = NULL;
-            out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -25931,6 +25931,19 @@ static void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(struct conv
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
+        {
+            VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
+            out_ext->pNext = NULL;
+            out_ext->flags = in_ext->flags;
+            out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
+            out_ext->pFixedRateFlags = UlongToPtr(in_ext->pFixedRateFlags);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
         {
             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -25943,26 +25956,24 @@ static void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(struct conv
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV:
         {
-            VkSwapchainPresentBarrierCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkSwapchainPresentBarrierCreateInfoNV32 *in_ext = (const VkSwapchainPresentBarrierCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV;
+            VkSwapchainLatencyCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkSwapchainLatencyCreateInfoNV32 *in_ext = (const VkSwapchainLatencyCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->presentBarrierEnable = in_ext->presentBarrierEnable;
+            out_ext->latencyModeEnable = in_ext->latencyModeEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
         {
-            VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
+            VkSwapchainPresentBarrierCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkSwapchainPresentBarrierCreateInfoNV32 *in_ext = (const VkSwapchainPresentBarrierCreateInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
-            out_ext->pFixedRateFlags = UlongToPtr(in_ext->pFixedRateFlags);
+            out_ext->presentBarrierEnable = in_ext->presentBarrierEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -25992,17 +26003,6 @@ static void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(struct conv
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV:
-        {
-            VkSwapchainLatencyCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkSwapchainLatencyCreateInfoNV32 *in_ext = (const VkSwapchainLatencyCreateInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV;
-            out_ext->pNext = NULL;
-            out_ext->latencyModeEnable = in_ext->latencyModeEnable;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -26061,24 +26061,24 @@ static void convert_VkTensorCreateInfoARM_win32_to_host(struct conversion_contex
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM:
         {
-            VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
+            VkExternalMemoryTensorCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkExternalMemoryTensorCreateInfoARM32 *in_ext = (const VkExternalMemoryTensorCreateInfoARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM;
             out_ext->pNext = NULL;
-            out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData);
+            out_ext->handleTypes = in_ext->handleTypes;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM:
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
         {
-            VkExternalMemoryTensorCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkExternalMemoryTensorCreateInfoARM32 *in_ext = (const VkExternalMemoryTensorCreateInfoARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM;
+            VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->handleTypes = in_ext->handleTypes;
+            out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -26161,18 +26161,6 @@ static void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conversion_
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR:
-        {
-            VkVideoEncodeH264SessionCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeH264SessionCreateInfoKHR32 *in_ext = (const VkVideoEncodeH264SessionCreateInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->useMaxLevelIdc = in_ext->useMaxLevelIdc;
-            out_ext->maxLevelIdc = in_ext->maxLevelIdc;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR:
         {
             VkVideoEncodeAV1SessionCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -26185,6 +26173,18 @@ static void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conversion_
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR:
+        {
+            VkVideoEncodeH264SessionCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeH264SessionCreateInfoKHR32 *in_ext = (const VkVideoEncodeH264SessionCreateInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR;
+            out_ext->pNext = NULL;
+            out_ext->useMaxLevelIdc = in_ext->useMaxLevelIdc;
+            out_ext->maxLevelIdc = in_ext->maxLevelIdc;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR:
         {
             VkVideoEncodeSessionIntraRefreshCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -26203,6 +26203,42 @@ static void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conversion_
     }
 }

+static void convert_StdVideoAV1SequenceHeader_win32_to_host(const StdVideoAV1SequenceHeader32 *in, StdVideoAV1SequenceHeader *out)
+{
+    if (!in) return;
+
+    out->flags = in->flags;
+    out->seq_profile = in->seq_profile;
+    out->frame_width_bits_minus_1 = in->frame_width_bits_minus_1;
+    out->frame_height_bits_minus_1 = in->frame_height_bits_minus_1;
+    out->max_frame_width_minus_1 = in->max_frame_width_minus_1;
+    out->max_frame_height_minus_1 = in->max_frame_height_minus_1;
+    out->delta_frame_id_length_minus_2 = in->delta_frame_id_length_minus_2;
+    out->additional_frame_id_length_minus_1 = in->additional_frame_id_length_minus_1;
+    out->order_hint_bits_minus_1 = in->order_hint_bits_minus_1;
+    out->seq_force_integer_mv = in->seq_force_integer_mv;
+    out->seq_force_screen_content_tools = in->seq_force_screen_content_tools;
+    memcpy(out->reserved1, in->reserved1, 5 * sizeof(uint8_t));
+    out->pColorConfig = UlongToPtr(in->pColorConfig);
+    out->pTimingInfo = UlongToPtr(in->pTimingInfo);
+}
+
+static const StdVideoAV1SequenceHeader *convert_StdVideoAV1SequenceHeader_array_win32_to_host(struct conversion_context *ctx, const StdVideoAV1SequenceHeader32 *in, uint32_t count)
+{
+    StdVideoAV1SequenceHeader *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_StdVideoAV1SequenceHeader_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
 static void convert_StdVideoH264SequenceParameterSetVui_win32_to_host(const StdVideoH264SequenceParameterSetVui32 *in, StdVideoH264SequenceParameterSetVui *out)
 {
     if (!in) return;
@@ -26351,42 +26387,6 @@ static const VkVideoDecodeH264SessionParametersAddInfoKHR *convert_VkVideoDecode
     return out;
 }

-static void convert_StdVideoAV1SequenceHeader_win32_to_host(const StdVideoAV1SequenceHeader32 *in, StdVideoAV1SequenceHeader *out)
-{
-    if (!in) return;
-
-    out->flags = in->flags;
-    out->seq_profile = in->seq_profile;
-    out->frame_width_bits_minus_1 = in->frame_width_bits_minus_1;
-    out->frame_height_bits_minus_1 = in->frame_height_bits_minus_1;
-    out->max_frame_width_minus_1 = in->max_frame_width_minus_1;
-    out->max_frame_height_minus_1 = in->max_frame_height_minus_1;
-    out->delta_frame_id_length_minus_2 = in->delta_frame_id_length_minus_2;
-    out->additional_frame_id_length_minus_1 = in->additional_frame_id_length_minus_1;
-    out->order_hint_bits_minus_1 = in->order_hint_bits_minus_1;
-    out->seq_force_integer_mv = in->seq_force_integer_mv;
-    out->seq_force_screen_content_tools = in->seq_force_screen_content_tools;
-    memcpy(out->reserved1, in->reserved1, 5 * sizeof(uint8_t));
-    out->pColorConfig = UlongToPtr(in->pColorConfig);
-    out->pTimingInfo = UlongToPtr(in->pTimingInfo);
-}
-
-static const StdVideoAV1SequenceHeader *convert_StdVideoAV1SequenceHeader_array_win32_to_host(struct conversion_context *ctx, const StdVideoAV1SequenceHeader32 *in, uint32_t count)
-{
-    StdVideoAV1SequenceHeader *out;
-    unsigned int i;
-
-    if (!in || !count) return NULL;
-
-    out = conversion_context_alloc(ctx, count * sizeof(*out));
-    for (i = 0; i < count; i++)
-    {
-        convert_StdVideoAV1SequenceHeader_win32_to_host(&in[i], &out[i]);
-    }
-
-    return out;
-}
-
 static void convert_VkVideoEncodeH264SessionParametersAddInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264SessionParametersAddInfoKHR32 *in, VkVideoEncodeH264SessionParametersAddInfoKHR *out)
 {
     if (!in) return;
@@ -26434,6 +26434,17 @@ static void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(struct c
     {
         switch (in_header->sType)
         {
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
+        {
+            VkVideoDecodeAV1SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoDecodeAV1SessionParametersCreateInfoKHR32 *in_ext = (const VkVideoDecodeAV1SessionParametersCreateInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR;
+            out_ext->pNext = NULL;
+            out_ext->pStdSequenceHeader = convert_StdVideoAV1SequenceHeader_array_win32_to_host(ctx, (const StdVideoAV1SequenceHeader32 *)UlongToPtr(in_ext->pStdSequenceHeader), 1);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
         {
             VkVideoDecodeH264SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -26447,24 +26458,29 @@ static void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(struct c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
         {
-            VkVideoDecodeAV1SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoDecodeAV1SessionParametersCreateInfoKHR32 *in_ext = (const VkVideoDecodeAV1SessionParametersCreateInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR;
+            VkVideoEncodeAV1SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeAV1SessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeAV1SessionParametersCreateInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR;
             out_ext->pNext = NULL;
             out_ext->pStdSequenceHeader = convert_StdVideoAV1SequenceHeader_array_win32_to_host(ctx, (const StdVideoAV1SequenceHeader32 *)UlongToPtr(in_ext->pStdSequenceHeader), 1);
+            out_ext->pStdDecoderModelInfo = UlongToPtr(in_ext->pStdDecoderModelInfo);
+            out_ext->stdOperatingPointCount = in_ext->stdOperatingPointCount;
+            out_ext->pStdOperatingPoints = UlongToPtr(in_ext->pStdOperatingPoints);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
         {
-            VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR;
+            VkVideoEncodeH264SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeH264SessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeH264SessionParametersCreateInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->quantizationMapTexelSize = in_ext->quantizationMapTexelSize;
+            out_ext->maxStdSPSCount = in_ext->maxStdSPSCount;
+            out_ext->maxStdPPSCount = in_ext->maxStdPPSCount;
+            out_ext->pParametersAddInfo = convert_VkVideoEncodeH264SessionParametersAddInfoKHR_array_win32_to_host(ctx, (const VkVideoEncodeH264SessionParametersAddInfoKHR32 *)UlongToPtr(in_ext->pParametersAddInfo), 1);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -26480,29 +26496,13 @@ static void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(struct c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
         {
-            VkVideoEncodeH264SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeH264SessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeH264SessionParametersCreateInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR;
+            VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->maxStdSPSCount = in_ext->maxStdSPSCount;
-            out_ext->maxStdPPSCount = in_ext->maxStdPPSCount;
-            out_ext->pParametersAddInfo = convert_VkVideoEncodeH264SessionParametersAddInfoKHR_array_win32_to_host(ctx, (const VkVideoEncodeH264SessionParametersAddInfoKHR32 *)UlongToPtr(in_ext->pParametersAddInfo), 1);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
-        {
-            VkVideoEncodeAV1SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoEncodeAV1SessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeAV1SessionParametersCreateInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->pStdSequenceHeader = convert_StdVideoAV1SequenceHeader_array_win32_to_host(ctx, (const StdVideoAV1SequenceHeader32 *)UlongToPtr(in_ext->pStdSequenceHeader), 1);
-            out_ext->pStdDecoderModelInfo = UlongToPtr(in_ext->pStdDecoderModelInfo);
-            out_ext->stdOperatingPointCount = in_ext->stdOperatingPointCount;
-            out_ext->pStdOperatingPoints = UlongToPtr(in_ext->pStdOperatingPoints);
+            out_ext->quantizationMapTexelSize = in_ext->quantizationMapTexelSize;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -27706,19 +27706,19 @@ static void convert_VkSubresourceLayout2_win32_to_host(struct conversion_context
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE:
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
         {
-            VkSubresourceHostMemcpySize *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE;
+            VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE:
         {
-            VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
+            VkSubresourceHostMemcpySize *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -27755,15 +27755,6 @@ static void convert_VkSubresourceLayout2_host_to_win32(const VkSubresourceLayout
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE:
-        {
-            VkSubresourceHostMemcpySize32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE);
-            const VkSubresourceHostMemcpySize *in_ext = (const VkSubresourceHostMemcpySize *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE;
-            out_ext->size = in_ext->size;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
         {
             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
@@ -27774,6 +27765,15 @@ static void convert_VkSubresourceLayout2_host_to_win32(const VkSubresourceLayout
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE:
+        {
+            VkSubresourceHostMemcpySize32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE);
+            const VkSubresourceHostMemcpySize *in_ext = (const VkSubresourceHostMemcpySize *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE;
+            out_ext->size = in_ext->size;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             break;
         }
@@ -28721,1689 +28721,1569 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
+            VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
+            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
+            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
+            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
+            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
+            VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute;
-            out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines;
-            out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay;
+            out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
+            out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
         {
-            VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
+            VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->privateData = in_ext->privateData;
+            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
+            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
+            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
         {
-            VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV;
+            VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure;
+            out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
         {
-            VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
+            VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
-            out_ext->variablePointers = in_ext->variablePointers;
+            out_ext->accelerationStructure = in_ext->accelerationStructure;
+            out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
+            out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
+            out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
+            out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
         {
-            VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
+            VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->multiview = in_ext->multiview;
-            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
-            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
+            out_ext->reportAddressBinding = in_ext->reportAddressBinding;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
         {
-            VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
+            VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAntiLagFeaturesAMD32 *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD;
             out_ext->pNext = NULL;
-            out_ext->presentId = in_ext->presentId;
+            out_ext->antiLag = in_ext->antiLag;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
         {
-            VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentId2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR;
+            VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->presentId2 = in_ext->presentId2;
+            out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
         {
-            VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
+            VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->presentWait = in_ext->presentWait;
+            out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
         {
-            VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentWait2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR;
+            VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->presentWait2 = in_ext->presentWait2;
+            out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
         {
-            VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
+            VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
-            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
-            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
-            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
+            out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
+            out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
         {
-            VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
+            VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
+            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
+            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
+            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
         {
-            VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
+            VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
+            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
+            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
+            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
         {
-            VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
+            VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->protectedMemory = in_ext->protectedMemory;
+            out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
         {
-            VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
+            VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
             out_ext->pNext = NULL;
-            out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
+            out_ext->clustercullingShader = in_ext->clustercullingShader;
+            out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
         {
-            VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
+            VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
             out_ext->pNext = NULL;
-            out_ext->multiDraw = in_ext->multiDraw;
+            out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
         {
-            VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
+            VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
-            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
+            out_ext->colorWriteEnable = in_ext->colorWriteEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
         {
-            VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
+            VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->maintenance4 = in_ext->maintenance4;
+            out_ext->commandBufferInheritance = in_ext->commandBufferInheritance;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
         {
-            VkPhysicalDeviceMaintenance5Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance5Features32 *in_ext = (const VkPhysicalDeviceMaintenance5Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
+            VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->maintenance5 = in_ext->maintenance5;
+            out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
+            out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
         {
-            VkPhysicalDeviceMaintenance6Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance6Features32 *in_ext = (const VkPhysicalDeviceMaintenance6Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
+            VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->maintenance6 = in_ext->maintenance6;
+            out_ext->conditionalRendering = in_ext->conditionalRendering;
+            out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
         {
-            VkPhysicalDeviceMaintenance8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance8FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR;
+            VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->maintenance8 = in_ext->maintenance8;
+            out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope;
+            out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions;
+            out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions;
+            out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions;
+            out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations;
+            out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing;
+            out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
         {
-            VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMaintenance9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR;
+            VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->maintenance9 = in_ext->maintenance9;
+            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
+            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
+            VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
+            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
+            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
+            VkPhysicalDeviceCooperativeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shaderFloat16 = in_ext->shaderFloat16;
-            out_ext->shaderInt8 = in_ext->shaderInt8;
+            out_ext->cooperativeVector = in_ext->cooperativeVector;
+            out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
         {
-            VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
+            VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->hostQueryReset = in_ext->hostQueryReset;
+            out_ext->indirectCopy = in_ext->indirectCopy;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
         {
-            VkPhysicalDeviceGlobalPriorityQueryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
+            VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
+            out_ext->cornerSampledImage = in_ext->cornerSampledImage;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
         {
-            VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
+            VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
-            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
-            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
-            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
-            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
-            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
-            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
-            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
-            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
-            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
-            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
-            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
-            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
-            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
+            out_ext->coverageReductionMode = in_ext->coverageReductionMode;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
         {
-            VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
+            VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCubicClampFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
+            out_ext->cubicRangeClamp = in_ext->cubicRangeClamp;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
         {
-            VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
+            VkPhysicalDeviceCubicWeightsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
-            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
-            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
+            out_ext->selectableCubicWeights = in_ext->selectableCubicWeights;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
         {
-            VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
+            VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->conditionalRendering = in_ext->conditionalRendering;
-            out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
+            out_ext->customBorderColors = in_ext->customBorderColors;
+            out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM:
         {
-            VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
+            VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDataGraphFeaturesARM32 *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
-            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
-            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
+            out_ext->dataGraph = in_ext->dataGraph;
+            out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind;
+            out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants;
+            out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer;
+            out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
+            VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
-            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
+            out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
+            VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
-            out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
-            out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
-            out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
-            out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
-            out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
-            out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
-            out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
-            out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
-            out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
-            out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
-            out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
+            out_ext->depthBiasControl = in_ext->depthBiasControl;
+            out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
+            out_ext->floatRepresentation = in_ext->floatRepresentation;
+            out_ext->depthBiasExact = in_ext->depthBiasExact;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
+            VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
-            out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
-            out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
-            out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
-            out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
-            out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
-            out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
-            out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
-            out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
-            out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
-            out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
-            out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
+            out_ext->depthClampControl = in_ext->depthClampControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
         {
-            VkPhysicalDeviceVertexAttributeDivisorFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
+            VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
-            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
+            out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
+            VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
+            out_ext->depthClipControl = in_ext->depthClipControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
         {
-            VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
+            VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->transformFeedback = in_ext->transformFeedback;
-            out_ext->geometryStreams = in_ext->geometryStreams;
+            out_ext->depthClipEnable = in_ext->depthClipEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
         {
-            VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
+            VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
+            out_ext->descriptorBuffer = in_ext->descriptorBuffer;
+            out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
+            out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
+            out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
         {
-            VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
+            VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->exclusiveScissor = in_ext->exclusiveScissor;
+            out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
         {
-            VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
+            VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->cornerSampledImage = in_ext->cornerSampledImage;
+            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
+            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
+            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
+            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
+            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
+            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
+            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
+            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
+            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
+            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
+            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
+            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
+            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
+            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
         {
-            VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
+            VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
-            out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
+            out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
         {
-            VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
+            VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
             out_ext->pNext = NULL;
-            out_ext->imageFootprint = in_ext->imageFootprint;
+            out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
         {
-            VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
+            VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
+            out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute;
+            out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines;
+            out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
         {
-            VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
+            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->indirectCopy = in_ext->indirectCopy;
+            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
+            out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
         {
-            VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
+            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->memoryDecompression = in_ext->memoryDecompression;
+            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
         {
-            VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
+            VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->shadingRateImage = in_ext->shadingRateImage;
-            out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
+            out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
         {
-            VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
+            VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->invocationMask = in_ext->invocationMask;
+            out_ext->dynamicRendering = in_ext->dynamicRendering;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
         {
-            VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
+            VkPhysicalDeviceDynamicRenderingLocalReadFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->taskShader = in_ext->taskShader;
-            out_ext->meshShader = in_ext->meshShader;
+            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
         {
-            VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
+            VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->taskShader = in_ext->taskShader;
-            out_ext->meshShader = in_ext->meshShader;
-            out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
-            out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
-            out_ext->meshShaderQueries = in_ext->meshShaderQueries;
+            out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
         {
-            VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
+            VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->accelerationStructure = in_ext->accelerationStructure;
-            out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
-            out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
-            out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
-            out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
+            out_ext->exclusiveScissor = in_ext->exclusiveScissor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
         {
-            VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
+            VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
-            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
-            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
-            out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
-            out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
+            out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
+            out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
+            out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
         {
-            VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
+            VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->rayQuery = in_ext->rayQuery;
+            out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
+            out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
+            out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
+            out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
+            out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
+            out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
+            out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
+            out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
+            out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
+            out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
+            out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
+            out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
+            out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
+            out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
+            out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
+            out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
+            out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
+            out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
+            out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
+            out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
+            out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
+            out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
+            out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
+            out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
+            out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
+            out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
+            out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
+            out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
+            out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
+            out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
+            out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
         {
-            VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
+            VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
-            out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
+            out_ext->extendedDynamicState = in_ext->extendedDynamicState;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
         {
-            VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
+            VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
-            out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
-            out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
+            out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
+            VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
+            out_ext->deviceFault = in_ext->deviceFault;
+            out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
         {
-            VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT;
+            VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFormatPackFeaturesARM32 *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
+            out_ext->formatPack = in_ext->formatPack;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
         {
-            VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
+            VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
+            out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
         {
-            VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
+            VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
+            out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
+            out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
+            out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE:
         {
-            VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
+            VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE;
             out_ext->pNext = NULL;
-            out_ext->depthClipEnable = in_ext->depthClipEnable;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
         {
-            VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
+            VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->memoryPriority = in_ext->memoryPriority;
+            out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
         {
-            VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
+            VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
+            out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
         {
-            VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
+            VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
-            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
-            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
+            out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
+            out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
+            out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
         {
-            VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
+            VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
-            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
-            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
+            out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
+            out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
+            out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
         {
-            VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
+            VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
+            out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
+            out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
+            out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
         {
-            VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
+            VkPhysicalDeviceFrameBoundaryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
+            out_ext->frameBoundary = in_ext->frameBoundary;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
         {
-            VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
+            VkPhysicalDeviceGlobalPriorityQueryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
-            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
+            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
         {
-            VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
+            VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
+            out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
         {
-            VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
+            VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI;
             out_ext->pNext = NULL;
-            out_ext->presentBarrier = in_ext->presentBarrier;
+            out_ext->hdrVivid = in_ext->hdrVivid;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
         {
-            VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
+            VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceHostImageCopyFeatures32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
-            out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
+            out_ext->hostImageCopy = in_ext->hostImageCopy;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
         {
-            VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
+            VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->coverageReductionMode = in_ext->coverageReductionMode;
+            out_ext->hostQueryReset = in_ext->hostQueryReset;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
+            VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
+            out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
+            out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
         {
-            VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
+            VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA;
             out_ext->pNext = NULL;
-            out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
-            out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
+            out_ext->imageAlignmentControl = in_ext->imageAlignmentControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDeviceIndexTypeUint8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceIndexTypeUint8Features32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
+            VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
+            out_ext->imageCompressionControl = in_ext->imageCompressionControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
+            VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
+            out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
         {
-            VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
+            VkPhysicalDeviceImageProcessing2FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
-            out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
-            out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
+            out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
         {
-            VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
+            VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
+            out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
+            out_ext->textureBoxFilter = in_ext->textureBoxFilter;
+            out_ext->textureBlockMatch = in_ext->textureBlockMatch;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
         {
-            VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
+            VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
-            out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
+            out_ext->robustImageAccess = in_ext->robustImageAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
+            VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
+            out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
+            VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
+            out_ext->minLod = in_ext->minLod;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
         {
-            VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
+            VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
+            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
         {
-            VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
+            VkPhysicalDeviceIndexTypeUint8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceIndexTypeUint8Features32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
-            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
+            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
         {
-            VkPhysicalDeviceLineRasterizationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceLineRasterizationFeatures32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
+            VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->rectangularLines = in_ext->rectangularLines;
-            out_ext->bresenhamLines = in_ext->bresenhamLines;
-            out_ext->smoothLines = in_ext->smoothLines;
-            out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
-            out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
-            out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
+            out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
         {
-            VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
+            VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
+            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
+            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
         {
-            VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
+            VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
             out_ext->pNext = NULL;
-            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
-            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
-            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
-            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
-            out_ext->multiview = in_ext->multiview;
-            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
-            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
-            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
-            out_ext->variablePointers = in_ext->variablePointers;
-            out_ext->protectedMemory = in_ext->protectedMemory;
-            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
-            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
+            out_ext->invocationMask = in_ext->invocationMask;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
         {
-            VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
+            VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
-            out_ext->drawIndirectCount = in_ext->drawIndirectCount;
-            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
-            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
-            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
-            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
-            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
-            out_ext->shaderFloat16 = in_ext->shaderFloat16;
-            out_ext->shaderInt8 = in_ext->shaderInt8;
-            out_ext->descriptorIndexing = in_ext->descriptorIndexing;
-            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
-            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
-            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
-            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
-            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
-            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
-            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
-            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
-            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
-            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
-            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
-            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
-            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
-            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
-            out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
-            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
-            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
-            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
-            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
-            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
-            out_ext->hostQueryReset = in_ext->hostQueryReset;
-            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
-            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
-            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
-            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
-            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
-            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
-            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
-            out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
-            out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
-            out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
+            out_ext->legacyDithering = in_ext->legacyDithering;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
         {
-            VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
+            VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->robustImageAccess = in_ext->robustImageAccess;
-            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
-            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
-            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
-            out_ext->privateData = in_ext->privateData;
-            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
-            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
-            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
-            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
-            out_ext->synchronization2 = in_ext->synchronization2;
-            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
-            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
-            out_ext->dynamicRendering = in_ext->dynamicRendering;
-            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
-            out_ext->maintenance4 = in_ext->maintenance4;
+            out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
         {
-            VkPhysicalDeviceVulkan14Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVulkan14Features32 *in_ext = (const VkPhysicalDeviceVulkan14Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES;
+            VkPhysicalDeviceLineRasterizationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceLineRasterizationFeatures32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
-            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
-            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
-            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
-            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
             out_ext->rectangularLines = in_ext->rectangularLines;
             out_ext->bresenhamLines = in_ext->bresenhamLines;
             out_ext->smoothLines = in_ext->smoothLines;
             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
-            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
-            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
-            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
-            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
-            out_ext->maintenance5 = in_ext->maintenance5;
-            out_ext->maintenance6 = in_ext->maintenance6;
-            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
-            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
-            out_ext->hostImageCopy = in_ext->hostImageCopy;
-            out_ext->pushDescriptor = in_ext->pushDescriptor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
         {
-            VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
+            VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
+            out_ext->linearColorAttachment = in_ext->linearColorAttachment;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
         {
-            VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
+            VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->customBorderColors = in_ext->customBorderColors;
-            out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
+            out_ext->maintenance4 = in_ext->maintenance4;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
         {
-            VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
+            VkPhysicalDeviceMaintenance5Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance5Features32 *in_ext = (const VkPhysicalDeviceMaintenance5Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
-            out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
+            out_ext->maintenance5 = in_ext->maintenance5;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
         {
-            VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
+            VkPhysicalDeviceMaintenance6Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance6Features32 *in_ext = (const VkPhysicalDeviceMaintenance6Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->extendedDynamicState = in_ext->extendedDynamicState;
+            out_ext->maintenance6 = in_ext->maintenance6;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
         {
-            VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
+            VkPhysicalDeviceMaintenance8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance8FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
-            out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
-            out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
+            out_ext->maintenance8 = in_ext->maintenance8;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
         {
-            VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
+            VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMaintenance9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
-            out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
-            out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
-            out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
-            out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
-            out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
-            out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
-            out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
-            out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
-            out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
-            out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
-            out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
-            out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
-            out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
-            out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
-            out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
-            out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
-            out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
-            out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
-            out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
-            out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
-            out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
-            out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
-            out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
-            out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
-            out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
-            out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
-            out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
-            out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
-            out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
-            out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
+            out_ext->maintenance9 = in_ext->maintenance9;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
         {
-            VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV;
+            VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure;
+            out_ext->memoryMapPlaced = in_ext->memoryMapPlaced;
+            out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced;
+            out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
         {
-            VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
+            VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
+            out_ext->memoryDecompression = in_ext->memoryDecompression;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
         {
-            VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
+            VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
+            out_ext->memoryPriority = in_ext->memoryPriority;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
+            VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
+            out_ext->taskShader = in_ext->taskShader;
+            out_ext->meshShader = in_ext->meshShader;
+            out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
+            out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
+            out_ext->meshShaderQueries = in_ext->meshShaderQueries;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
         {
-            VkPhysicalDeviceRobustness2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRobustness2FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
+            VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
-            out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
-            out_ext->nullDescriptor = in_ext->nullDescriptor;
+            out_ext->taskShader = in_ext->taskShader;
+            out_ext->meshShader = in_ext->meshShader;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
         {
-            VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
+            VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->robustImageAccess = in_ext->robustImageAccess;
+            out_ext->multiDraw = in_ext->multiDraw;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
         {
-            VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
+            VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
-            out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
-            out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
-            out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
+            out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
         {
-            VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
+            VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
-            out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
+            out_ext->multiview = in_ext->multiview;
+            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
+            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
         {
-            VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
+            VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->subpassShading = in_ext->subpassShading;
+            out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
         {
-            VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
+            VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->clustercullingShader = in_ext->clustercullingShader;
-            out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
+            out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
+            VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
-            out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
+            out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
+            VkPhysicalDeviceNestedCommandBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
-            out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
-            out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
+            out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer;
+            out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering;
+            out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
+            VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
+            out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
+            VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
-            out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
-            out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
+            out_ext->micromap = in_ext->micromap;
+            out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
+            out_ext->micromapHostCommands = in_ext->micromapHostCommands;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
         {
-            VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
+            VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
-            out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
+            out_ext->opticalFlow = in_ext->opticalFlow;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
         {
-            VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
+            VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
+            out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
         {
-            VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
+            VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
+            out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
         {
-            VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT;
+            VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes;
+            out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet;
+            out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
         {
-            VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
+            VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
+            out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
+            out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
         {
-            VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
+            VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->depthClipControl = in_ext->depthClipControl;
+            out_ext->pipelineBinaries = in_ext->pipelineBinaries;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
         {
-            VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT;
+            VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC;
             out_ext->pNext = NULL;
-            out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory;
+            out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
+            VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
-            out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout;
+            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
         {
-            VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
-            out_ext->pNext = NULL;
-            out_ext->depthClampControl = in_ext->depthClampControl;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
-        {
-            VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
+            VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
+            out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR;
+            VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction;
+            out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
         {
-            VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
+            VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->colorWriteEnable = in_ext->colorWriteEnable;
+            out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
         {
-            VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
+            VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->synchronization2 = in_ext->synchronization2;
+            out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
         {
-            VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR;
+            VkPhysicalDevicePipelineProtectedAccessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineProtectedAccessFeatures32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts;
-            out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo;
+            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
         {
-            VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceHostImageCopyFeatures32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
+            VkPhysicalDevicePipelineRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePipelineRobustnessFeatures32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->hostImageCopy = in_ext->hostImageCopy;
+            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
         {
-            VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
+            VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
-            out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
-            out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
+            out_ext->presentBarrier = in_ext->presentBarrier;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
         {
-            VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
+            VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentId2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->legacyDithering = in_ext->legacyDithering;
+            out_ext->presentId2 = in_ext->presentId2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
         {
-            VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
+            VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
+            out_ext->presentId = in_ext->presentId;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
         {
-            VkPhysicalDevicePipelineProtectedAccessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineProtectedAccessFeatures32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
+            VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
+            out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
         {
-            VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR;
+            VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentWait2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->videoMaintenance1 = in_ext->videoMaintenance1;
+            out_ext->presentWait2 = in_ext->presentWait2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
         {
-            VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR;
+            VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9;
+            out_ext->presentWait = in_ext->presentWait;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
         {
-            VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR;
+            VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap;
+            out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
+            out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
         {
-            VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR;
+            VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1;
+            out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
+            out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
+            out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
         {
-            VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
+            VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
+            out_ext->privateData = in_ext->privateData;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
         {
-            VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
+            VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
+            out_ext->protectedMemory = in_ext->protectedMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -30420,72 +30300,59 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
-        {
-            VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR;
-            out_ext->pNext = NULL;
-            out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
         {
-            VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
+            VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->descriptorBuffer = in_ext->descriptorBuffer;
-            out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
-            out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
-            out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
+            out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
+            VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
+            out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
+            out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
+            out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
         {
-            VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
+            VkPhysicalDeviceRawAccessChainsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
+            out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
         {
-            VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
+            VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
-            out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
+            out_ext->rayQuery = in_ext->rayQuery;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
         {
-            VkPhysicalDeviceRayTracingValidationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV;
+            VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->rayTracingValidation = in_ext->rayTracingValidation;
+            out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -30502,909 +30369,1042 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
         {
-            VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
+            VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
+            out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
+            out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
         {
-            VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
+            VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->dynamicRendering = in_ext->dynamicRendering;
+            out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
+            out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
         {
-            VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
+            VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->minLod = in_ext->minLod;
+            out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
+            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
+            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
+            out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
+            out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
         {
-            VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
+            VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
-            out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
-            out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
+            out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
         {
-            VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
+            VkPhysicalDeviceRayTracingValidationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->linearColorAttachment = in_ext->linearColorAttachment;
+            out_ext->rayTracingValidation = in_ext->rayTracingValidation;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
         {
-            VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
+            VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG;
             out_ext->pNext = NULL;
-            out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
+            out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
         {
-            VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR;
+            VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->pipelineBinaries = in_ext->pipelineBinaries;
+            out_ext->renderPassStriped = in_ext->renderPassStriped;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
         {
-            VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
+            VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
+            out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
         {
-            VkPhysicalDeviceNestedCommandBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT;
+            VkPhysicalDeviceRobustness2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceRobustness2FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer;
-            out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering;
-            out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse;
+            out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
+            out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
+            out_ext->nullDescriptor = in_ext->nullDescriptor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
         {
-            VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
+            VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
+            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
         {
-            VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
+            VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->imageCompressionControl = in_ext->imageCompressionControl;
+            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
         {
-            VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
+            VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
+            out_ext->schedulingControls = in_ext->schedulingControls;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
         {
-            VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
+            VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
+            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
         {
-            VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
+            VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->micromap = in_ext->micromap;
-            out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
-            out_ext->micromapHostCommands = in_ext->micromapHostCommands;
+            out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
+            VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
+            out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
+            out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
+            out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
+            out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
+            out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
+            out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
+            out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
+            out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
+            out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
+            out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
+            out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
+            out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
+            VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
+            out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
+            out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
+            out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
+            out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
+            out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
+            out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
+            out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
+            out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
+            out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
+            out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
+            out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
+            out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
         {
-            VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
+            VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
+            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
+            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
         {
-            VkPhysicalDevicePipelineRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineRobustnessFeatures32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
+            VkPhysicalDeviceShaderBfloat16FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
+            out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type;
+            out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct;
+            out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
         {
-            VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
+            VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
-            out_ext->textureBoxFilter = in_ext->textureBoxFilter;
-            out_ext->textureBlockMatch = in_ext->textureBlockMatch;
+            out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
+            out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
         {
-            VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
+            VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->tileProperties = in_ext->tileProperties;
+            out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
         {
-            VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
+            VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
+            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
         {
-            VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
+            VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->reportAddressBinding = in_ext->reportAddressBinding;
+            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
         {
-            VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
+            VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
             out_ext->pNext = NULL;
-            out_ext->opticalFlow = in_ext->opticalFlow;
+            out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
         {
-            VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
+            VkPhysicalDeviceShaderExpectAssumeFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderExpectAssumeFeatures32 *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->deviceFault = in_ext->deviceFault;
-            out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
+            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
         {
-            VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
+            VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
+            out_ext->shaderFloat16 = in_ext->shaderFloat16;
+            out_ext->shaderInt8 = in_ext->shaderInt8;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
+            VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
+            out_ext->shaderFloat8 = in_ext->shaderFloat8;
+            out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
         {
-            VkPhysicalDeviceFrameBoundaryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT;
+            VkPhysicalDeviceShaderFloatControls2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderFloatControls2Features32 *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->frameBoundary = in_ext->frameBoundary;
+            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
         {
-            VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
+            VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
+            out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
+            out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
         {
-            VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
+            VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
+            out_ext->imageFootprint = in_ext->imageFootprint;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
         {
-            VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
+            VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->depthBiasControl = in_ext->depthBiasControl;
-            out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
-            out_ext->floatRepresentation = in_ext->floatRepresentation;
-            out_ext->depthBiasExact = in_ext->depthBiasExact;
+            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
         {
-            VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
+            VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
             out_ext->pNext = NULL;
-            out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
+            out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
         {
-            VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV;
+            VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace;
+            out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
         {
-            VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
+            VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
+            out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
         {
-            VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
+            VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
+            out_ext->shaderObject = in_ext->shaderObject;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
         {
-            VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
+            VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
+            out_ext->shaderQuadControl = in_ext->shaderQuadControl;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
         {
-            VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
+            VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->shaderObject = in_ext->shaderObject;
+            out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
+            VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
-            out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
-            out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
+            out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
         {
-            VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
+            VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
-            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
+            out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
         {
-            VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceAntiLagFeaturesAMD32 *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD;
+            VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->antiLag = in_ext->antiLag;
+            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
         {
-            VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM;
+            VkPhysicalDeviceShaderSubgroupRotateFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->tileMemoryHeap = in_ext->tileMemoryHeap;
+            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
+            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
         {
-            VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCubicClampFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM;
+            VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->cubicRangeClamp = in_ext->cubicRangeClamp;
+            out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
         {
-            VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM;
+            VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->ycbcrDegamma = in_ext->ycbcrDegamma;
+            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
         {
-            VkPhysicalDeviceCubicWeightsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM;
+            VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->selectableCubicWeights = in_ext->selectableCubicWeights;
+            out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
+            out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
+            out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
         {
-            VkPhysicalDeviceImageProcessing2FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM;
+            VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2;
+            out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
         {
-            VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV;
+            VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
             out_ext->pNext = NULL;
-            out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation;
+            out_ext->shadingRateImage = in_ext->shadingRateImage;
+            out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
         {
-            VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV;
+            VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet;
-            out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout;
+            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
+            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
         {
-            VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM;
+            VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->schedulingControls = in_ext->schedulingControls;
+            out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
         {
-            VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG;
+            VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
             out_ext->pNext = NULL;
-            out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization;
+            out_ext->subpassShading = in_ext->subpassShading;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
         {
-            VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM;
+            VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->renderPassStriped = in_ext->renderPassStriped;
+            out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
         {
-            VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM;
+            VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap;
+            out_ext->synchronization2 = in_ext->synchronization2;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
         {
-            VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR;
+            VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceTensorFeaturesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM;
             out_ext->pNext = NULL;
-            out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence;
+            out_ext->tensorNonPacked = in_ext->tensorNonPacked;
+            out_ext->shaderTensorAccess = in_ext->shaderTensorAccess;
+            out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing;
+            out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing;
+            out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind;
+            out_ext->tensors = in_ext->tensors;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderSubgroupRotateFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
+            VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
-            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
+            out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
         {
-            VkPhysicalDeviceShaderExpectAssumeFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderExpectAssumeFeatures32 *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
+            VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
+            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderFloatControls2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderFloatControls2Features32 *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
+            VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
+            out_ext->tileMemoryHeap = in_ext->tileMemoryHeap;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
         {
-            VkPhysicalDeviceDynamicRenderingLocalReadFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
+            VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
+            out_ext->tileProperties = in_ext->tileProperties;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR;
+            VkPhysicalDeviceTileShadingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTileShadingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->shaderQuadControl = in_ext->shaderQuadControl;
+            out_ext->tileShading = in_ext->tileShading;
+            out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage;
+            out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments;
+            out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments;
+            out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments;
+            out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments;
+            out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments;
+            out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw;
+            out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch;
+            out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile;
+            out_ext->tileShadingApron = in_ext->tileShadingApron;
+            out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron;
+            out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps;
+            out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
         {
-            VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV;
+            VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics;
+            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
         {
-            VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
+            VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->memoryMapPlaced = in_ext->memoryMapPlaced;
-            out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced;
-            out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve;
+            out_ext->transformFeedback = in_ext->transformFeedback;
+            out_ext->geometryStreams = in_ext->geometryStreams;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
         {
-            VkPhysicalDeviceShaderBfloat16FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR;
+            VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type;
-            out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct;
-            out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix;
+            out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts;
+            out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
         {
-            VkPhysicalDeviceRawAccessChainsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV;
+            VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains;
+            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
         {
-            VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV;
+            VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->commandBufferInheritance = in_ext->commandBufferInheritance;
+            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
+            out_ext->variablePointers = in_ext->variablePointers;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
         {
-            VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA;
+            VkPhysicalDeviceVertexAttributeDivisorFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->imageAlignmentControl = in_ext->imageAlignmentControl;
+            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
+            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT;
+            VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites;
+            out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
         {
-            VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR;
+            VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady;
+            out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
         {
-            VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV;
+            VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope;
-            out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions;
-            out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions;
-            out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions;
-            out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations;
-            out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing;
-            out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads;
+            out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
         {
-            VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI;
+            VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->hdrVivid = in_ext->hdrVivid;
+            out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
         {
-            VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT;
+            VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness;
+            out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
         {
-            VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
+            VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
+            out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
         {
-            VkPhysicalDeviceCooperativeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV;
+            VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->cooperativeVector = in_ext->cooperativeVector;
-            out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining;
+            out_ext->videoMaintenance1 = in_ext->videoMaintenance1;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
         {
-            VkPhysicalDeviceTileShadingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTileShadingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM;
+            VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->tileShading = in_ext->tileShading;
-            out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage;
-            out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments;
-            out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments;
-            out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments;
-            out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments;
-            out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments;
-            out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw;
-            out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch;
-            out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile;
-            out_ext->tileShadingApron = in_ext->tileShadingApron;
-            out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron;
-            out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps;
-            out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing;
+            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
+            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
+            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
+            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
+            out_ext->multiview = in_ext->multiview;
+            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
+            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
+            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
+            out_ext->variablePointers = in_ext->variablePointers;
+            out_ext->protectedMemory = in_ext->protectedMemory;
+            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
+            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
         {
-            VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE;
+            VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
             out_ext->pNext = NULL;
+            out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
+            out_ext->drawIndirectCount = in_ext->drawIndirectCount;
+            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
+            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
+            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
+            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
+            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
+            out_ext->shaderFloat16 = in_ext->shaderFloat16;
+            out_ext->shaderInt8 = in_ext->shaderInt8;
+            out_ext->descriptorIndexing = in_ext->descriptorIndexing;
+            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
+            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
+            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
+            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
+            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
+            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
+            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
+            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
+            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
+            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
+            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
+            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
+            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
+            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
+            out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
+            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
+            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
+            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
+            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
+            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
+            out_ext->hostQueryReset = in_ext->hostQueryReset;
+            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
+            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
+            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
+            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
+            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
+            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
+            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
+            out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
+            out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
+            out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
         {
-            VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceFormatPackFeaturesARM32 *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM;
+            VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->formatPack = in_ext->formatPack;
+            out_ext->robustImageAccess = in_ext->robustImageAccess;
+            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
+            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
+            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
+            out_ext->privateData = in_ext->privateData;
+            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
+            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
+            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
+            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
+            out_ext->synchronization2 = in_ext->synchronization2;
+            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
+            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
+            out_ext->dynamicRendering = in_ext->dynamicRendering;
+            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
+            out_ext->maintenance4 = in_ext->maintenance4;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
         {
-            VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceTensorFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM;
+            VkPhysicalDeviceVulkan14Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkan14Features32 *in_ext = (const VkPhysicalDeviceVulkan14Features32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->tensorNonPacked = in_ext->tensorNonPacked;
-            out_ext->shaderTensorAccess = in_ext->shaderTensorAccess;
-            out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing;
-            out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing;
-            out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind;
-            out_ext->tensors = in_ext->tensors;
+            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
+            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
+            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
+            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
+            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
+            out_ext->rectangularLines = in_ext->rectangularLines;
+            out_ext->bresenhamLines = in_ext->bresenhamLines;
+            out_ext->smoothLines = in_ext->smoothLines;
+            out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
+            out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
+            out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
+            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
+            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
+            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
+            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
+            out_ext->maintenance5 = in_ext->maintenance5;
+            out_ext->maintenance6 = in_ext->maintenance6;
+            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
+            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
+            out_ext->hostImageCopy = in_ext->hostImageCopy;
+            out_ext->pushDescriptor = in_ext->pushDescriptor;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
         {
-            VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM;
+            VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
             out_ext->pNext = NULL;
-            out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors;
+            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
+            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
+            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
         {
-            VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT;
+            VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
             out_ext->pNext = NULL;
-            out_ext->shaderFloat8 = in_ext->shaderFloat8;
-            out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix;
+            out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
+            out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
+            out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
+            out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
         {
-            VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDataGraphFeaturesARM32 *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM;
+            VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->dataGraph = in_ext->dataGraph;
-            out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind;
-            out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants;
-            out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer;
-            out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule;
+            out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
         {
-            VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC;
+            VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM;
             out_ext->pNext = NULL;
-            out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode;
+            out_ext->ycbcrDegamma = in_ext->ycbcrDegamma;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR;
+            VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
             out_ext->pNext = NULL;
-            out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers;
+            out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
+        {
+            VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT;
+            out_ext->pNext = NULL;
+            out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
+        {
+            VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
+            out_ext->pNext = NULL;
+            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -31429,555 +31429,609 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV);
-            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
-            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
+            VkPhysicalDevice16BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
+            const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
+            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
+            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
+            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
+            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV);
-            const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
-            out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute;
-            out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines;
-            out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay;
+            VkPhysicalDevice4444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
+            const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
+            out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
+            out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
         {
-            VkPhysicalDevicePrivateDataFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES);
-            const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
-            out_ext->privateData = in_ext->privateData;
+            VkPhysicalDevice8BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
+            const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
+            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
+            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
+            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
         {
-            VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV);
-            const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV;
-            out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure;
+            VkPhysicalDeviceASTCDecodeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT);
+            const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
+            out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
         {
-            VkPhysicalDeviceVariablePointersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
-            const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
-            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
-            out_ext->variablePointers = in_ext->variablePointers;
+            VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR);
+            const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
+            out_ext->accelerationStructure = in_ext->accelerationStructure;
+            out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
+            out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
+            out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
+            out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
         {
-            VkPhysicalDeviceMultiviewFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
-            const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
-            out_ext->multiview = in_ext->multiview;
-            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
-            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
+            VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT);
+            const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
+            out_ext->reportAddressBinding = in_ext->reportAddressBinding;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
         {
-            VkPhysicalDevicePresentIdFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR);
-            const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
-            out_ext->presentId = in_ext->presentId;
+            VkPhysicalDeviceAntiLagFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD);
+            const VkPhysicalDeviceAntiLagFeaturesAMD *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD;
+            out_ext->antiLag = in_ext->antiLag;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
         {
-            VkPhysicalDevicePresentId2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR);
-            const VkPhysicalDevicePresentId2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR;
-            out_ext->presentId2 = in_ext->presentId2;
+            VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT);
+            const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
+            out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
         {
-            VkPhysicalDevicePresentWaitFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR);
-            const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
-            out_ext->presentWait = in_ext->presentWait;
+            VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT);
+            const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
+            out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
         {
-            VkPhysicalDevicePresentWait2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR);
-            const VkPhysicalDevicePresentWait2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR;
-            out_ext->presentWait2 = in_ext->presentWait2;
+            VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT);
+            const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
+            out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
         {
-            VkPhysicalDevice16BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
-            const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
-            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
-            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
-            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
-            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
+            VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT);
+            const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
+            out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
+            out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
         {
-            VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
-            const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
-            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
+            VkPhysicalDeviceBufferDeviceAddressFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
+            const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
+            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
+            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
+            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
         {
-            VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
-            const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
-            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
+            VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT);
+            const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
+            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
+            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
+            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
         {
-            VkPhysicalDeviceProtectedMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
-            const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
-            out_ext->protectedMemory = in_ext->protectedMemory;
+            VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV);
+            const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV;
+            out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
         {
-            VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT);
-            const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
-            out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
+            VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI);
+            const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
+            out_ext->clustercullingShader = in_ext->clustercullingShader;
+            out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
         {
-            VkPhysicalDeviceMultiDrawFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT);
-            const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
-            out_ext->multiDraw = in_ext->multiDraw;
+            VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD);
+            const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
+            out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
         {
-            VkPhysicalDeviceInlineUniformBlockFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
-            const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
-            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
-            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
+            VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT);
+            const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
+            out_ext->colorWriteEnable = in_ext->colorWriteEnable;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
         {
-            VkPhysicalDeviceMaintenance4Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
-            const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
-            out_ext->maintenance4 = in_ext->maintenance4;
+            VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV);
+            const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV;
+            out_ext->commandBufferInheritance = in_ext->commandBufferInheritance;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
         {
-            VkPhysicalDeviceMaintenance5Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES);
-            const VkPhysicalDeviceMaintenance5Features *in_ext = (const VkPhysicalDeviceMaintenance5Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
-            out_ext->maintenance5 = in_ext->maintenance5;
+            VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR);
+            const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
+            out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
+            out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
         {
-            VkPhysicalDeviceMaintenance6Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES);
-            const VkPhysicalDeviceMaintenance6Features *in_ext = (const VkPhysicalDeviceMaintenance6Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
-            out_ext->maintenance6 = in_ext->maintenance6;
+            VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
+            const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
+            out_ext->conditionalRendering = in_ext->conditionalRendering;
+            out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
         {
-            VkPhysicalDeviceMaintenance8FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR);
-            const VkPhysicalDeviceMaintenance8FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR;
-            out_ext->maintenance8 = in_ext->maintenance8;
+            VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV);
+            const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV;
+            out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope;
+            out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions;
+            out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions;
+            out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions;
+            out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations;
+            out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing;
+            out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
         {
-            VkPhysicalDeviceMaintenance9FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR);
-            const VkPhysicalDeviceMaintenance9FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR;
-            out_ext->maintenance9 = in_ext->maintenance9;
+            VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR);
+            const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
+            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
+            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderDrawParametersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
-            const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
-            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
+            VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV);
+            const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
+            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
+            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderFloat16Int8Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
-            const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
-            out_ext->shaderFloat16 = in_ext->shaderFloat16;
-            out_ext->shaderInt8 = in_ext->shaderInt8;
+            VkPhysicalDeviceCooperativeVectorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV);
+            const VkPhysicalDeviceCooperativeVectorFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV;
+            out_ext->cooperativeVector = in_ext->cooperativeVector;
+            out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
         {
-            VkPhysicalDeviceHostQueryResetFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
-            const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
-            out_ext->hostQueryReset = in_ext->hostQueryReset;
-            out_header = (void *)out_ext;
+            VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV);
+            const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
+            out_ext->indirectCopy = in_ext->indirectCopy;
+            out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
         {
-            VkPhysicalDeviceGlobalPriorityQueryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES);
-            const VkPhysicalDeviceGlobalPriorityQueryFeatures *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
-            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
+            VkPhysicalDeviceCornerSampledImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV);
+            const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
+            out_ext->cornerSampledImage = in_ext->cornerSampledImage;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
         {
-            VkPhysicalDeviceDescriptorIndexingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
-            const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
-            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
-            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
-            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
-            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
-            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
-            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
-            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
-            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
-            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
-            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
-            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
-            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
-            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
-            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
+            VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV);
+            const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
+            out_ext->coverageReductionMode = in_ext->coverageReductionMode;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
         {
-            VkPhysicalDeviceTimelineSemaphoreFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
-            const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
-            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
+            VkPhysicalDeviceCubicClampFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM);
+            const VkPhysicalDeviceCubicClampFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM;
+            out_ext->cubicRangeClamp = in_ext->cubicRangeClamp;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
         {
-            VkPhysicalDevice8BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
-            const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
-            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
-            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
-            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
+            VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM);
+            const VkPhysicalDeviceCubicWeightsFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM;
+            out_ext->selectableCubicWeights = in_ext->selectableCubicWeights;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
         {
-            VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
-            const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
-            out_ext->conditionalRendering = in_ext->conditionalRendering;
-            out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
+            VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
+            const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
+            out_ext->customBorderColors = in_ext->customBorderColors;
+            out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM:
         {
-            VkPhysicalDeviceVulkanMemoryModelFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
-            const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
-            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
-            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
-            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
+            VkPhysicalDeviceDataGraphFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM);
+            const VkPhysicalDeviceDataGraphFeaturesARM *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM;
+            out_ext->dataGraph = in_ext->dataGraph;
+            out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind;
+            out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants;
+            out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer;
+            out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderAtomicInt64Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
-            const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
-            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
-            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
+            VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV);
+            const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
+            out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT);
-            const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
-            out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
-            out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
-            out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
-            out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
-            out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
-            out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
-            out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
-            out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
-            out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
-            out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
-            out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
-            out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
+            VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT);
+            const VkPhysicalDeviceDepthBiasControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
+            out_ext->depthBiasControl = in_ext->depthBiasControl;
+            out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
+            out_ext->floatRepresentation = in_ext->floatRepresentation;
+            out_ext->depthBiasExact = in_ext->depthBiasExact;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT);
-            const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
-            out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
-            out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
-            out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
-            out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
-            out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
-            out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
-            out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
-            out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
-            out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
-            out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
-            out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
-            out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
+            VkPhysicalDeviceDepthClampControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT);
+            const VkPhysicalDeviceDepthClampControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
+            out_ext->depthClampControl = in_ext->depthClampControl;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
         {
-            VkPhysicalDeviceVertexAttributeDivisorFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES);
-            const VkPhysicalDeviceVertexAttributeDivisorFeatures *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
-            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
-            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
+            VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR);
+            const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
+            out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDeviceASTCDecodeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT);
-            const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
-            out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
+            VkPhysicalDeviceDepthClipControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT);
+            const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
+            out_ext->depthClipControl = in_ext->depthClipControl;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
         {
-            VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
-            const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
-            out_ext->transformFeedback = in_ext->transformFeedback;
-            out_ext->geometryStreams = in_ext->geometryStreams;
+            VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
+            const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
+            out_ext->depthClipEnable = in_ext->depthClipEnable;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
         {
-            VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV);
-            const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
-            out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
+            VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT);
+            const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
+            out_ext->descriptorBuffer = in_ext->descriptorBuffer;
+            out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
+            out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
+            out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
         {
-            VkPhysicalDeviceExclusiveScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV);
-            const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
-            out_ext->exclusiveScissor = in_ext->exclusiveScissor;
+            VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM);
+            const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM;
+            out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
         {
-            VkPhysicalDeviceCornerSampledImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV);
-            const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
-            out_ext->cornerSampledImage = in_ext->cornerSampledImage;
+            VkPhysicalDeviceDescriptorIndexingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
+            const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
+            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
+            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
+            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
+            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
+            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
+            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
+            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
+            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
+            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
+            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
+            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
+            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
+            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
+            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
         {
-            VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR);
-            const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
-            out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
-            out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
+            VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV);
+            const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV;
+            out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
         {
-            VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV);
-            const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
-            out_ext->imageFootprint = in_ext->imageFootprint;
+            VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE);
+            const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
+            out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
         {
-            VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV);
-            const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
-            out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
+            VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV);
+            const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
+            out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute;
+            out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines;
+            out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
         {
-            VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV);
-            const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
-            out_ext->indirectCopy = in_ext->indirectCopy;
+            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT);
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
+            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
+            out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
         {
-            VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV);
-            const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
-            out_ext->memoryDecompression = in_ext->memoryDecompression;
+            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV);
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
+            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
         {
-            VkPhysicalDeviceShadingRateImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV);
-            const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
-            out_ext->shadingRateImage = in_ext->shadingRateImage;
-            out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
+            VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV);
+            const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
+            out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
         {
-            VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI);
-            const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
-            out_ext->invocationMask = in_ext->invocationMask;
+            VkPhysicalDeviceDynamicRenderingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
+            const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
+            out_ext->dynamicRendering = in_ext->dynamicRendering;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
         {
-            VkPhysicalDeviceMeshShaderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV);
-            const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
-            out_ext->taskShader = in_ext->taskShader;
-            out_ext->meshShader = in_ext->meshShader;
+            VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES);
+            const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
+            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
         {
-            VkPhysicalDeviceMeshShaderFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT);
-            const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
-            out_ext->taskShader = in_ext->taskShader;
-            out_ext->meshShader = in_ext->meshShader;
-            out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
-            out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
-            out_ext->meshShaderQueries = in_ext->meshShaderQueries;
+            VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT);
+            const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
+            out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
         {
-            VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR);
-            const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
-            out_ext->accelerationStructure = in_ext->accelerationStructure;
-            out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
-            out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
-            out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
-            out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
+            VkPhysicalDeviceExclusiveScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV);
+            const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
+            out_ext->exclusiveScissor = in_ext->exclusiveScissor;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
         {
-            VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR);
-            const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
-            out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
-            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
-            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
-            out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
-            out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
+            VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
+            const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
+            out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
+            out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
+            out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
         {
-            VkPhysicalDeviceRayQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR);
-            const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
-            out_ext->rayQuery = in_ext->rayQuery;
+            VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT);
+            const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
+            out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
+            out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
+            out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
+            out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
+            out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
+            out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
+            out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
+            out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
+            out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
+            out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
+            out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
+            out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
+            out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
+            out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
+            out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
+            out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
+            out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
+            out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
+            out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
+            out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
+            out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
+            out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
+            out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
+            out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
+            out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
+            out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
+            out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
+            out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
+            out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
+            out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
+            out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
         {
-            VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR);
-            const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
-            out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
-            out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
+            VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
+            const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
+            out_ext->extendedDynamicState = in_ext->extendedDynamicState;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
+        {
+            VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV);
+            const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV;
+            out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
+        {
+            VkPhysicalDeviceFaultFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT);
+            const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
+            out_ext->deviceFault = in_ext->deviceFault;
+            out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
+        {
+            VkPhysicalDeviceFormatPackFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM);
+            const VkPhysicalDeviceFormatPackFeaturesARM *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM;
+            out_ext->formatPack = in_ext->formatPack;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
+        {
+            VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT);
+            const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
+            out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
             out_header = (void *)out_ext;
             break;
         }
@@ -31992,12 +32046,12 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE:
         {
-            VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT);
-            const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
-            out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
+            VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE);
+            const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *in_ext = (const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE;
+            out_ext->fragmentDensityMapLayered = in_ext->fragmentDensityMapLayered;
             out_header = (void *)out_ext;
             break;
         }
@@ -32010,239 +32064,247 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
         {
-            VkPhysicalDeviceScalarBlockLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
-            const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
-            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
+            VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR);
+            const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
+            out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
         {
-            VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
-            const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
-            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
+            VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT);
+            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
+            out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
+            out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
+            out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
         {
-            VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
-            const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
-            out_ext->depthClipEnable = in_ext->depthClipEnable;
+            VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV);
+            const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
+            out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
+            out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
+            out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
         {
-            VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT);
-            const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
-            out_ext->memoryPriority = in_ext->memoryPriority;
+            VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR);
+            const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
+            out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
+            out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
+            out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
         {
-            VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT);
-            const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
-            out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
+            VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT);
+            const VkPhysicalDeviceFrameBoundaryFeaturesEXT *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT;
+            out_ext->frameBoundary = in_ext->frameBoundary;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
         {
-            VkPhysicalDeviceBufferDeviceAddressFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
-            const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
-            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
-            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
-            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
+            VkPhysicalDeviceGlobalPriorityQueryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES);
+            const VkPhysicalDeviceGlobalPriorityQueryFeatures *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
+            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
         {
-            VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT);
-            const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
-            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
-            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
-            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
+            VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT);
+            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
+            out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
         {
-            VkPhysicalDeviceImagelessFramebufferFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
-            const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
-            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
+            VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI);
+            const VkPhysicalDeviceHdrVividFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI;
+            out_ext->hdrVivid = in_ext->hdrVivid;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
         {
-            VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
-            const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
-            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
+            VkPhysicalDeviceHostImageCopyFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES);
+            const VkPhysicalDeviceHostImageCopyFeatures *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
+            out_ext->hostImageCopy = in_ext->hostImageCopy;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
         {
-            VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV);
-            const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
-            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
-            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
+            VkPhysicalDeviceHostQueryResetFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
+            const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
+            out_ext->hostQueryReset = in_ext->hostQueryReset;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
         {
-            VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT);
-            const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
-            out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
+            VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT);
+            const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
+            out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
+            out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
         {
-            VkPhysicalDevicePresentBarrierFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV);
-            const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
-            out_ext->presentBarrier = in_ext->presentBarrier;
+            VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA);
+            const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA;
+            out_ext->imageAlignmentControl = in_ext->imageAlignmentControl;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
         {
-            VkPhysicalDevicePerformanceQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR);
-            const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
-            out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
-            out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
+            VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT);
+            const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
+            out_ext->imageCompressionControl = in_ext->imageCompressionControl;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
         {
-            VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV);
-            const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
-            out_ext->coverageReductionMode = in_ext->coverageReductionMode;
+            VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT);
+            const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
+            out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL);
-            const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
-            out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
+            VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM);
+            const VkPhysicalDeviceImageProcessing2FeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM;
+            out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderClockFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR);
-            const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
-            out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
-            out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
+            VkPhysicalDeviceImageProcessingFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM);
+            const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
+            out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
+            out_ext->textureBoxFilter = in_ext->textureBoxFilter;
+            out_ext->textureBlockMatch = in_ext->textureBlockMatch;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
         {
-            VkPhysicalDeviceIndexTypeUint8Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES);
-            const VkPhysicalDeviceIndexTypeUint8Features *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
-            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
+            VkPhysicalDeviceImageRobustnessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
+            const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
+            out_ext->robustImageAccess = in_ext->robustImageAccess;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV);
-            const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
-            out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
+            VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT);
+            const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
+            out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT);
-            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
-            out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
-            out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
-            out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
+            VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
+            const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
+            out_ext->minLod = in_ext->minLod;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
         {
-            VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
-            const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
-            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
+            VkPhysicalDeviceImagelessFramebufferFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
+            const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
+            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
         {
-            VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT);
-            const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
-            out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
-            out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
+            VkPhysicalDeviceIndexTypeUint8Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES);
+            const VkPhysicalDeviceIndexTypeUint8Features *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
+            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
         {
-            VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR);
-            const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
-            out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
+            VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV);
+            const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
+            out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
         {
-            VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
-            const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
-            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
+            VkPhysicalDeviceInlineUniformBlockFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
+            const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
+            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
+            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
         {
-            VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
-            const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
-            out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
+            VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI);
+            const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
+            out_ext->invocationMask = in_ext->invocationMask;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
         {
-            VkPhysicalDeviceSubgroupSizeControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
-            const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
-            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
-            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
+            VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT);
+            const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
+            out_ext->legacyDithering = in_ext->legacyDithering;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
+        {
+            VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT);
+            const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT;
+            out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes;
             out_header = (void *)out_ext;
             break;
         }
@@ -32260,654 +32322,526 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
         {
-            VkPhysicalDevicePipelineCreationCacheControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
-            const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
-            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
+            VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV);
+            const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
+            out_ext->linearColorAttachment = in_ext->linearColorAttachment;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
         {
-            VkPhysicalDeviceVulkan11Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
-            const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
-            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
-            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
-            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
-            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
-            out_ext->multiview = in_ext->multiview;
-            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
-            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
-            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
-            out_ext->variablePointers = in_ext->variablePointers;
-            out_ext->protectedMemory = in_ext->protectedMemory;
-            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
-            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
-        {
-            VkPhysicalDeviceVulkan12Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
-            const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
-            out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
-            out_ext->drawIndirectCount = in_ext->drawIndirectCount;
-            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
-            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
-            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
-            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
-            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
-            out_ext->shaderFloat16 = in_ext->shaderFloat16;
-            out_ext->shaderInt8 = in_ext->shaderInt8;
-            out_ext->descriptorIndexing = in_ext->descriptorIndexing;
-            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
-            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
-            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
-            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
-            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
-            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
-            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
-            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
-            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
-            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
-            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
-            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
-            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
-            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
-            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
-            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
-            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
-            out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
-            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
-            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
-            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
-            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
-            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
-            out_ext->hostQueryReset = in_ext->hostQueryReset;
-            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
-            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
-            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
-            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
-            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
-            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
-            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
-            out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
-            out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
-            out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
+            VkPhysicalDeviceMaintenance4Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
+            const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
+            out_ext->maintenance4 = in_ext->maintenance4;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
         {
-            VkPhysicalDeviceVulkan13Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
-            const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
-            out_ext->robustImageAccess = in_ext->robustImageAccess;
-            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
-            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
-            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
-            out_ext->privateData = in_ext->privateData;
-            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
-            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
-            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
-            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
-            out_ext->synchronization2 = in_ext->synchronization2;
-            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
-            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
-            out_ext->dynamicRendering = in_ext->dynamicRendering;
-            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
-            out_ext->maintenance4 = in_ext->maintenance4;
+            VkPhysicalDeviceMaintenance5Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES);
+            const VkPhysicalDeviceMaintenance5Features *in_ext = (const VkPhysicalDeviceMaintenance5Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
+            out_ext->maintenance5 = in_ext->maintenance5;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
         {
-            VkPhysicalDeviceVulkan14Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES);
-            const VkPhysicalDeviceVulkan14Features *in_ext = (const VkPhysicalDeviceVulkan14Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES;
-            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
-            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
-            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
-            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
-            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
-            out_ext->rectangularLines = in_ext->rectangularLines;
-            out_ext->bresenhamLines = in_ext->bresenhamLines;
-            out_ext->smoothLines = in_ext->smoothLines;
-            out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
-            out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
-            out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
-            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
-            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
-            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
-            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
-            out_ext->maintenance5 = in_ext->maintenance5;
+            VkPhysicalDeviceMaintenance6Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES);
+            const VkPhysicalDeviceMaintenance6Features *in_ext = (const VkPhysicalDeviceMaintenance6Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
             out_ext->maintenance6 = in_ext->maintenance6;
-            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
-            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
-            out_ext->hostImageCopy = in_ext->hostImageCopy;
-            out_ext->pushDescriptor = in_ext->pushDescriptor;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
         {
-            VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD);
-            const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
-            out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
+            VkPhysicalDeviceMaintenance8FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR);
+            const VkPhysicalDeviceMaintenance8FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR;
+            out_ext->maintenance8 = in_ext->maintenance8;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
         {
-            VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
-            const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
-            out_ext->customBorderColors = in_ext->customBorderColors;
-            out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
+            VkPhysicalDeviceMaintenance9FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR);
+            const VkPhysicalDeviceMaintenance9FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR;
+            out_ext->maintenance9 = in_ext->maintenance9;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
         {
-            VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT);
-            const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
-            out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
-            out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
+            VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT);
+            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
+            out_ext->memoryMapPlaced = in_ext->memoryMapPlaced;
+            out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced;
+            out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
         {
-            VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
-            const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
-            out_ext->extendedDynamicState = in_ext->extendedDynamicState;
+            VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV);
+            const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
+            out_ext->memoryDecompression = in_ext->memoryDecompression;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
         {
-            VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
-            const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
-            out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
-            out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
-            out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
+            VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT);
+            const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
+            out_ext->memoryPriority = in_ext->memoryPriority;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
         {
-            VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT);
-            const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
-            out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
-            out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
-            out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
-            out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
-            out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
-            out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
-            out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
-            out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
-            out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
-            out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
-            out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
-            out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
-            out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
-            out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
-            out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
-            out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
-            out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
-            out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
-            out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
-            out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
-            out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
-            out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
-            out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
-            out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
-            out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
-            out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
-            out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
-            out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
-            out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
-            out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
-            out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
+            VkPhysicalDeviceMeshShaderFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT);
+            const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
+            out_ext->taskShader = in_ext->taskShader;
+            out_ext->meshShader = in_ext->meshShader;
+            out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
+            out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
+            out_ext->meshShaderQueries = in_ext->meshShaderQueries;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
         {
-            VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV);
-            const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV;
-            out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure;
+            VkPhysicalDeviceMeshShaderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV);
+            const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
+            out_ext->taskShader = in_ext->taskShader;
+            out_ext->meshShader = in_ext->meshShader;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
         {
-            VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV);
-            const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
-            out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
+            VkPhysicalDeviceMultiDrawFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT);
+            const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
+            out_ext->multiDraw = in_ext->multiDraw;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
         {
-            VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
-            const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
-            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
+            VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT);
+            const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
+            out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
         {
-            VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR);
-            const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
-            out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
+            VkPhysicalDeviceMultiviewFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
+            const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
+            out_ext->multiview = in_ext->multiview;
+            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
+            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
         {
-            VkPhysicalDeviceRobustness2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR);
-            const VkPhysicalDeviceRobustness2FeaturesKHR *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
-            out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
-            out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
-            out_ext->nullDescriptor = in_ext->nullDescriptor;
+            VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM);
+            const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
+            out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
         {
-            VkPhysicalDeviceImageRobustnessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
-            const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
-            out_ext->robustImageAccess = in_ext->robustImageAccess;
+            VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM);
+            const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
+            out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
         {
-            VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR);
-            const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
-            out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
-            out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
-            out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
-            out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
+            VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT);
+            const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
+            out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
         {
-            VkPhysicalDevice4444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
-            const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
-            out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
-            out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
+            VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT);
+            const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT;
+            out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer;
+            out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering;
+            out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
         {
-            VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI);
-            const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
-            out_ext->subpassShading = in_ext->subpassShading;
+            VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT);
+            const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
+            out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
         {
-            VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI);
-            const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
-            out_ext->clustercullingShader = in_ext->clustercullingShader;
-            out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
+            VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT);
+            const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
+            out_ext->micromap = in_ext->micromap;
+            out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
+            out_ext->micromapHostCommands = in_ext->micromapHostCommands;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT);
-            const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
-            out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
-            out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
+            VkPhysicalDeviceOpticalFlowFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV);
+            const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
+            out_ext->opticalFlow = in_ext->opticalFlow;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
         {
-            VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR);
-            const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
-            out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
-            out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
-            out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
+            VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT);
+            const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
+            out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderTerminateInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
-            const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
-            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
+            VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV);
+            const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV;
+            out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
         {
-            VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV);
-            const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
-            out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
-            out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
-            out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
+            VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV);
+            const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV;
+            out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet;
+            out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
         {
-            VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT);
-            const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
-            out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
-            out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
+            VkPhysicalDevicePerformanceQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR);
+            const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
+            out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
+            out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
         {
-            VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT);
-            const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
-            out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
+            VkPhysicalDevicePipelineBinaryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR);
+            const VkPhysicalDevicePipelineBinaryFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR;
+            out_ext->pipelineBinaries = in_ext->pipelineBinaries;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
         {
-            VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT);
-            const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
-            out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
+            VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC);
+            const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC;
+            out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
         {
-            VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT);
-            const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT;
-            out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes;
+            VkPhysicalDevicePipelineCreationCacheControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
+            const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
+            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
         {
-            VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT);
-            const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
-            out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
+            VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR);
+            const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
+            out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
         {
-            VkPhysicalDeviceDepthClipControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT);
-            const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
-            out_ext->depthClipControl = in_ext->depthClipControl;
+            VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT);
+            const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
+            out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
         {
-            VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT);
-            const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT;
-            out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory;
+            VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM);
+            const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM;
+            out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT);
-            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
-            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
-            out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout;
+            VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT);
+            const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
+            out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
         {
-            VkPhysicalDeviceDepthClampControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT);
-            const VkPhysicalDeviceDepthClampControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
-            out_ext->depthClampControl = in_ext->depthClampControl;
+            VkPhysicalDevicePipelineProtectedAccessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES);
+            const VkPhysicalDevicePipelineProtectedAccessFeatures *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
+            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
         {
-            VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT);
-            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
-            out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
+            VkPhysicalDevicePipelineRobustnessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES);
+            const VkPhysicalDevicePipelineRobustnessFeatures *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
+            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR);
-            const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR;
-            out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction;
+            VkPhysicalDevicePresentBarrierFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV);
+            const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
+            out_ext->presentBarrier = in_ext->presentBarrier;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
         {
-            VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT);
-            const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
-            out_ext->colorWriteEnable = in_ext->colorWriteEnable;
+            VkPhysicalDevicePresentId2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR);
+            const VkPhysicalDevicePresentId2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR;
+            out_ext->presentId2 = in_ext->presentId2;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
         {
-            VkPhysicalDeviceSynchronization2Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
-            const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
-            out_ext->synchronization2 = in_ext->synchronization2;
+            VkPhysicalDevicePresentIdFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR);
+            const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
+            out_ext->presentId = in_ext->presentId;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
         {
-            VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR);
-            const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR;
-            out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts;
-            out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo;
+            VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR);
+            const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR;
+            out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
         {
-            VkPhysicalDeviceHostImageCopyFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES);
-            const VkPhysicalDeviceHostImageCopyFeatures *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
-            out_ext->hostImageCopy = in_ext->hostImageCopy;
+            VkPhysicalDevicePresentWait2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR);
+            const VkPhysicalDevicePresentWait2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR;
+            out_ext->presentWait2 = in_ext->presentWait2;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
         {
-            VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT);
-            const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
-            out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
-            out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
-            out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
+            VkPhysicalDevicePresentWaitFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR);
+            const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
+            out_ext->presentWait = in_ext->presentWait;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
         {
-            VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT);
-            const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
-            out_ext->legacyDithering = in_ext->legacyDithering;
+            VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT);
+            const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
+            out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
+            out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
         {
-            VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT);
-            const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
-            out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
+            VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT);
+            const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
+            out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
+            out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
+            out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
         {
-            VkPhysicalDevicePipelineProtectedAccessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES);
-            const VkPhysicalDevicePipelineProtectedAccessFeatures *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
-            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
+            VkPhysicalDevicePrivateDataFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES);
+            const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
+            out_ext->privateData = in_ext->privateData;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
         {
-            VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR);
-            const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR;
-            out_ext->videoMaintenance1 = in_ext->videoMaintenance1;
+            VkPhysicalDeviceProtectedMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
+            const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
+            out_ext->protectedMemory = in_ext->protectedMemory;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
         {
-            VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR);
-            const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR;
-            out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9;
+            VkPhysicalDeviceProvokingVertexFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
+            const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
+            out_ext->provokingVertexLast = in_ext->provokingVertexLast;
+            out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
         {
-            VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR);
-            const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR;
-            out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap;
+            VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT);
+            const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
+            out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
         {
-            VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR);
-            const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR;
-            out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1;
+            VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT);
+            const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
+            out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
+            out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
+            out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
         {
-            VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV);
-            const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
-            out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
+            VkPhysicalDeviceRawAccessChainsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV);
+            const VkPhysicalDeviceRawAccessChainsFeaturesNV *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV;
+            out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
         {
-            VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
-            const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
-            out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
+            VkPhysicalDeviceRayQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR);
+            const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
+            out_ext->rayQuery = in_ext->rayQuery;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
         {
-            VkPhysicalDeviceProvokingVertexFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
-            const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
-            out_ext->provokingVertexLast = in_ext->provokingVertexLast;
-            out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
+            VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV);
+            const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
+            out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
         {
-            VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR);
-            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR;
-            out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh;
+            VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV);
+            const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV;
+            out_ext->spheres = in_ext->spheres;
+            out_ext->linearSweptSpheres = in_ext->linearSweptSpheres;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
         {
-            VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT);
-            const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
-            out_ext->descriptorBuffer = in_ext->descriptorBuffer;
-            out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
-            out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
-            out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
+            VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR);
+            const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
+            out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
+            out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
         {
-            VkPhysicalDeviceShaderIntegerDotProductFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
-            const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
-            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
+            VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV);
+            const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
+            out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
+            out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
         {
-            VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR);
-            const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
-            out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
+            VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR);
+            const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
+            out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
+            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
+            out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
+            out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
+            out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
         {
-            VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV);
-            const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
-            out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
-            out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
+            VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR);
+            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
+            out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
             out_header = (void *)out_ext;
             break;
         }
@@ -32920,154 +32854,184 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
         {
-            VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV);
-            const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV;
-            out_ext->spheres = in_ext->spheres;
-            out_ext->linearSweptSpheres = in_ext->linearSweptSpheres;
+            VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG);
+            const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG;
+            out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
         {
-            VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT);
-            const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
-            out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
+            VkPhysicalDeviceRenderPassStripedFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM);
+            const VkPhysicalDeviceRenderPassStripedFeaturesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM;
+            out_ext->renderPassStriped = in_ext->renderPassStriped;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
         {
-            VkPhysicalDeviceDynamicRenderingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
-            const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
-            out_ext->dynamicRendering = in_ext->dynamicRendering;
+            VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV);
+            const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
+            out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
         {
-            VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
-            const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
-            out_ext->minLod = in_ext->minLod;
+            VkPhysicalDeviceRobustness2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR);
+            const VkPhysicalDeviceRobustness2FeaturesKHR *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
+            out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
+            out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
+            out_ext->nullDescriptor = in_ext->nullDescriptor;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
         {
-            VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT);
-            const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
-            out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
-            out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
-            out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
+            VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
+            const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
+            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
         {
-            VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV);
-            const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
-            out_ext->linearColorAttachment = in_ext->linearColorAttachment;
-            out_header = (void *)out_ext;
+            VkPhysicalDeviceScalarBlockLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
+            const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
+            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
+            out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
         {
-            VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT);
-            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
-            out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
+            VkPhysicalDeviceSchedulingControlsFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM);
+            const VkPhysicalDeviceSchedulingControlsFeaturesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM;
+            out_ext->schedulingControls = in_ext->schedulingControls;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
         {
-            VkPhysicalDevicePipelineBinaryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR);
-            const VkPhysicalDevicePipelineBinaryFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR;
-            out_ext->pipelineBinaries = in_ext->pipelineBinaries;
+            VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
+            const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
+            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
         {
-            VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE);
-            const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
-            out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
+            VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV);
+            const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV;
+            out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
         {
-            VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT);
-            const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT;
-            out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer;
-            out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering;
-            out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse;
+            VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT);
+            const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
+            out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
+            out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
+            out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
+            out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
+            out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
+            out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
+            out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
+            out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
+            out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
+            out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
+            out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
+            out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT);
-            const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
-            out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
+            VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT);
+            const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
+            out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
+            out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
+            out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
+            out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
+            out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
+            out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
+            out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
+            out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
+            out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
+            out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
+            out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
+            out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
         {
-            VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT);
-            const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
-            out_ext->imageCompressionControl = in_ext->imageCompressionControl;
+            VkPhysicalDeviceShaderAtomicInt64Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
+            const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
+            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
+            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
         {
-            VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT);
-            const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
-            out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
+            VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR);
+            const VkPhysicalDeviceShaderBfloat16FeaturesKHR *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR;
+            out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type;
+            out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct;
+            out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
         {
-            VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT);
-            const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
-            out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
+            VkPhysicalDeviceShaderClockFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR);
+            const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
+            out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
+            out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
         {
-            VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT);
-            const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
-            out_ext->micromap = in_ext->micromap;
-            out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
-            out_ext->micromapHostCommands = in_ext->micromapHostCommands;
+            VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM);
+            const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
+            out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
         {
-            VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT);
-            const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
-            out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
+            VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
+            const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
+            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+        {
+            VkPhysicalDeviceShaderDrawParametersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
+            const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
+            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
             out_header = (void *)out_ext;
             break;
         }
@@ -33080,189 +33044,178 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
         {
-            VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT);
-            const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
-            out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
+            VkPhysicalDeviceShaderExpectAssumeFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES);
+            const VkPhysicalDeviceShaderExpectAssumeFeatures *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
+            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
         {
-            VkPhysicalDevicePipelineRobustnessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES);
-            const VkPhysicalDevicePipelineRobustnessFeatures *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
-            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
+            VkPhysicalDeviceShaderFloat16Int8Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
+            const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
+            out_ext->shaderFloat16 = in_ext->shaderFloat16;
+            out_ext->shaderInt8 = in_ext->shaderInt8;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
         {
-            VkPhysicalDeviceImageProcessingFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM);
-            const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
-            out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
-            out_ext->textureBoxFilter = in_ext->textureBoxFilter;
-            out_ext->textureBlockMatch = in_ext->textureBlockMatch;
+            VkPhysicalDeviceShaderFloat8FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT);
+            const VkPhysicalDeviceShaderFloat8FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT;
+            out_ext->shaderFloat8 = in_ext->shaderFloat8;
+            out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
         {
-            VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM);
-            const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
-            out_ext->tileProperties = in_ext->tileProperties;
+            VkPhysicalDeviceShaderFloatControls2Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES);
+            const VkPhysicalDeviceShaderFloatControls2Features *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
+            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
         {
-            VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT);
-            const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
-            out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
+            VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT);
+            const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
+            out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
+            out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
         {
-            VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT);
-            const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
-            out_ext->reportAddressBinding = in_ext->reportAddressBinding;
+            VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV);
+            const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
+            out_ext->imageFootprint = in_ext->imageFootprint;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
         {
-            VkPhysicalDeviceOpticalFlowFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV);
-            const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
-            out_ext->opticalFlow = in_ext->opticalFlow;
+            VkPhysicalDeviceShaderIntegerDotProductFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
+            const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
+            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
         {
-            VkPhysicalDeviceFaultFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT);
-            const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
-            out_ext->deviceFault = in_ext->deviceFault;
-            out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
+            VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL);
+            const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
+            out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
         {
-            VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT);
-            const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
-            out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
+            VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR);
+            const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR;
+            out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM);
-            const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
-            out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
+            VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT);
+            const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
+            out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
         {
-            VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT);
-            const VkPhysicalDeviceFrameBoundaryFeaturesEXT *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT;
-            out_ext->frameBoundary = in_ext->frameBoundary;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
-        {
-            VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT);
-            const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
-            out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
+            VkPhysicalDeviceShaderObjectFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT);
+            const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
+            out_ext->shaderObject = in_ext->shaderObject;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
         {
-            VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR);
-            const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
-            out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
+            VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR);
+            const VkPhysicalDeviceShaderQuadControlFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR;
+            out_ext->shaderQuadControl = in_ext->shaderQuadControl;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
         {
-            VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT);
-            const VkPhysicalDeviceDepthBiasControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
-            out_ext->depthBiasControl = in_ext->depthBiasControl;
-            out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
-            out_ext->floatRepresentation = in_ext->floatRepresentation;
-            out_ext->depthBiasExact = in_ext->depthBiasExact;
+            VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR);
+            const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR;
+            out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
         {
-            VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV);
-            const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
-            out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
+            VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT);
+            const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT;
+            out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
         {
-            VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV);
-            const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV;
-            out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace;
+            VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV);
+            const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
+            out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
         {
-            VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM);
-            const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
-            out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
+            VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
+            const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
+            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
         {
-            VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR);
-            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
-            out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
+            VkPhysicalDeviceShaderSubgroupRotateFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES);
+            const VkPhysicalDeviceShaderSubgroupRotateFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
+            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
+            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
         {
-            VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM);
-            const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
-            out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
+            VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR);
+            const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
+            out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
         {
-            VkPhysicalDeviceShaderObjectFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT);
-            const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
-            out_ext->shaderObject = in_ext->shaderObject;
+            VkPhysicalDeviceShaderTerminateInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
+            const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
+            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
             out_header = (void *)out_ext;
             break;
         }
@@ -33277,409 +33230,456 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
         {
-            VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR);
-            const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
-            out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
-            out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
+            VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR);
+            const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR;
+            out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
         {
-            VkPhysicalDeviceAntiLagFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD);
-            const VkPhysicalDeviceAntiLagFeaturesAMD *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD;
-            out_ext->antiLag = in_ext->antiLag;
+            VkPhysicalDeviceShadingRateImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV);
+            const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
+            out_ext->shadingRateImage = in_ext->shadingRateImage;
+            out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
         {
-            VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM);
-            const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM;
-            out_ext->tileMemoryHeap = in_ext->tileMemoryHeap;
+            VkPhysicalDeviceSubgroupSizeControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
+            const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
+            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
+            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
         {
-            VkPhysicalDeviceCubicClampFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM);
-            const VkPhysicalDeviceCubicClampFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM;
-            out_ext->cubicRangeClamp = in_ext->cubicRangeClamp;
+            VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT);
+            const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
+            out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
         {
-            VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM);
-            const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM;
-            out_ext->ycbcrDegamma = in_ext->ycbcrDegamma;
+            VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI);
+            const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
+            out_ext->subpassShading = in_ext->subpassShading;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
         {
-            VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM);
-            const VkPhysicalDeviceCubicWeightsFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM;
-            out_ext->selectableCubicWeights = in_ext->selectableCubicWeights;
+            VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR);
+            const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
+            out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
         {
-            VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM);
-            const VkPhysicalDeviceImageProcessing2FeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM;
-            out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2;
+            VkPhysicalDeviceSynchronization2Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
+            const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
+            out_ext->synchronization2 = in_ext->synchronization2;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
         {
-            VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV);
-            const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV;
-            out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation;
+            VkPhysicalDeviceTensorFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM);
+            const VkPhysicalDeviceTensorFeaturesARM *in_ext = (const VkPhysicalDeviceTensorFeaturesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM;
+            out_ext->tensorNonPacked = in_ext->tensorNonPacked;
+            out_ext->shaderTensorAccess = in_ext->shaderTensorAccess;
+            out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing;
+            out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing;
+            out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind;
+            out_ext->tensors = in_ext->tensors;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
         {
-            VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV);
-            const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV;
-            out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet;
-            out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout;
+            VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
+            const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
+            out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
         {
-            VkPhysicalDeviceSchedulingControlsFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM);
-            const VkPhysicalDeviceSchedulingControlsFeaturesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM;
-            out_ext->schedulingControls = in_ext->schedulingControls;
+            VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
+            const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
+            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
         {
-            VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG);
-            const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG;
-            out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization;
+            VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM);
+            const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM;
+            out_ext->tileMemoryHeap = in_ext->tileMemoryHeap;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
         {
-            VkPhysicalDeviceRenderPassStripedFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM);
-            const VkPhysicalDeviceRenderPassStripedFeaturesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM;
-            out_ext->renderPassStriped = in_ext->renderPassStriped;
+            VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM);
+            const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
+            out_ext->tileProperties = in_ext->tileProperties;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
         {
-            VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM);
-            const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM;
-            out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap;
+            VkPhysicalDeviceTileShadingFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM);
+            const VkPhysicalDeviceTileShadingFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM;
+            out_ext->tileShading = in_ext->tileShading;
+            out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage;
+            out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments;
+            out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments;
+            out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments;
+            out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments;
+            out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments;
+            out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw;
+            out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch;
+            out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile;
+            out_ext->tileShadingApron = in_ext->tileShadingApron;
+            out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron;
+            out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps;
+            out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
         {
-            VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR);
-            const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR;
-            out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
-        {
-            VkPhysicalDeviceShaderSubgroupRotateFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES);
-            const VkPhysicalDeviceShaderSubgroupRotateFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
-            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
-            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
+            VkPhysicalDeviceTimelineSemaphoreFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
+            const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
+            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderExpectAssumeFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES);
-            const VkPhysicalDeviceShaderExpectAssumeFeatures *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
-            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
+            VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
+            const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
+            out_ext->transformFeedback = in_ext->transformFeedback;
+            out_ext->geometryStreams = in_ext->geometryStreams;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
         {
-            VkPhysicalDeviceShaderFloatControls2Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES);
-            const VkPhysicalDeviceShaderFloatControls2Features *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
-            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
+            VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR);
+            const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR;
+            out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts;
+            out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
         {
-            VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES);
-            const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
-            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
+            VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
+            const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
+            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
         {
-            VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR);
-            const VkPhysicalDeviceShaderQuadControlFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR;
-            out_ext->shaderQuadControl = in_ext->shaderQuadControl;
+            VkPhysicalDeviceVariablePointersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
+            const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
+            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
+            out_ext->variablePointers = in_ext->variablePointers;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
         {
-            VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV);
-            const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV;
-            out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics;
+            VkPhysicalDeviceVertexAttributeDivisorFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES);
+            const VkPhysicalDeviceVertexAttributeDivisorFeatures *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
+            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
+            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
         {
-            VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT);
-            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
-            out_ext->memoryMapPlaced = in_ext->memoryMapPlaced;
-            out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced;
-            out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve;
+            VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT);
+            const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT;
+            out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
         {
-            VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR);
-            const VkPhysicalDeviceShaderBfloat16FeaturesKHR *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR;
-            out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type;
-            out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct;
-            out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix;
+            VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT);
+            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
+            out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
         {
-            VkPhysicalDeviceRawAccessChainsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV);
-            const VkPhysicalDeviceRawAccessChainsFeaturesNV *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV;
-            out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains;
+            VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR);
+            const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR;
+            out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
         {
-            VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV);
-            const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV;
-            out_ext->commandBufferInheritance = in_ext->commandBufferInheritance;
+            VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR);
+            const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR;
+            out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
         {
-            VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA);
-            const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA;
-            out_ext->imageAlignmentControl = in_ext->imageAlignmentControl;
+            VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR);
+            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR;
+            out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
         {
-            VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT);
-            const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT;
-            out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites;
+            VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR);
+            const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR;
+            out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
         {
-            VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR);
-            const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR;
-            out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady;
+            VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR);
+            const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR;
+            out_ext->videoMaintenance1 = in_ext->videoMaintenance1;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
         {
-            VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV);
-            const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV;
-            out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope;
-            out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions;
-            out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions;
-            out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions;
-            out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations;
-            out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing;
-            out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads;
+            VkPhysicalDeviceVulkan11Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
+            const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
+            out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
+            out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
+            out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
+            out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
+            out_ext->multiview = in_ext->multiview;
+            out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
+            out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
+            out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
+            out_ext->variablePointers = in_ext->variablePointers;
+            out_ext->protectedMemory = in_ext->protectedMemory;
+            out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
+            out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
         {
-            VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI);
-            const VkPhysicalDeviceHdrVividFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI;
-            out_ext->hdrVivid = in_ext->hdrVivid;
+            VkPhysicalDeviceVulkan12Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
+            const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
+            out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
+            out_ext->drawIndirectCount = in_ext->drawIndirectCount;
+            out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
+            out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
+            out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
+            out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
+            out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
+            out_ext->shaderFloat16 = in_ext->shaderFloat16;
+            out_ext->shaderInt8 = in_ext->shaderInt8;
+            out_ext->descriptorIndexing = in_ext->descriptorIndexing;
+            out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
+            out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
+            out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
+            out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
+            out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
+            out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
+            out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
+            out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
+            out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
+            out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
+            out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
+            out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
+            out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
+            out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
+            out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
+            out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
+            out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
+            out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
+            out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
+            out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
+            out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
+            out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
+            out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
+            out_ext->hostQueryReset = in_ext->hostQueryReset;
+            out_ext->timelineSemaphore = in_ext->timelineSemaphore;
+            out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
+            out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
+            out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
+            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
+            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
+            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
+            out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
+            out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
+            out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
         {
-            VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT);
-            const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT;
-            out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness;
+            VkPhysicalDeviceVulkan13Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
+            const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
+            out_ext->robustImageAccess = in_ext->robustImageAccess;
+            out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
+            out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
+            out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
+            out_ext->privateData = in_ext->privateData;
+            out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
+            out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
+            out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
+            out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
+            out_ext->synchronization2 = in_ext->synchronization2;
+            out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
+            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
+            out_ext->dynamicRendering = in_ext->dynamicRendering;
+            out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
+            out_ext->maintenance4 = in_ext->maintenance4;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
         {
-            VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR);
-            const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
-            out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
-        {
-            VkPhysicalDeviceCooperativeVectorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV);
-            const VkPhysicalDeviceCooperativeVectorFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV;
-            out_ext->cooperativeVector = in_ext->cooperativeVector;
-            out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
-        {
-            VkPhysicalDeviceTileShadingFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM);
-            const VkPhysicalDeviceTileShadingFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM;
-            out_ext->tileShading = in_ext->tileShading;
-            out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage;
-            out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments;
-            out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments;
-            out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments;
-            out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments;
-            out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments;
-            out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw;
-            out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch;
-            out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile;
-            out_ext->tileShadingApron = in_ext->tileShadingApron;
-            out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron;
-            out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps;
-            out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE:
-        {
-            VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE);
-            const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *in_ext = (const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE;
-            out_ext->fragmentDensityMapLayered = in_ext->fragmentDensityMapLayered;
+            VkPhysicalDeviceVulkan14Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES);
+            const VkPhysicalDeviceVulkan14Features *in_ext = (const VkPhysicalDeviceVulkan14Features *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES;
+            out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
+            out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate;
+            out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered;
+            out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2;
+            out_ext->shaderExpectAssume = in_ext->shaderExpectAssume;
+            out_ext->rectangularLines = in_ext->rectangularLines;
+            out_ext->bresenhamLines = in_ext->bresenhamLines;
+            out_ext->smoothLines = in_ext->smoothLines;
+            out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
+            out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
+            out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
+            out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
+            out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
+            out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
+            out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead;
+            out_ext->maintenance5 = in_ext->maintenance5;
+            out_ext->maintenance6 = in_ext->maintenance6;
+            out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
+            out_ext->pipelineRobustness = in_ext->pipelineRobustness;
+            out_ext->hostImageCopy = in_ext->hostImageCopy;
+            out_ext->pushDescriptor = in_ext->pushDescriptor;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
         {
-            VkPhysicalDeviceFormatPackFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM);
-            const VkPhysicalDeviceFormatPackFeaturesARM *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM;
-            out_ext->formatPack = in_ext->formatPack;
+            VkPhysicalDeviceVulkanMemoryModelFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
+            const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
+            out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
+            out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
+            out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
         {
-            VkPhysicalDeviceTensorFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM);
-            const VkPhysicalDeviceTensorFeaturesARM *in_ext = (const VkPhysicalDeviceTensorFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM;
-            out_ext->tensorNonPacked = in_ext->tensorNonPacked;
-            out_ext->shaderTensorAccess = in_ext->shaderTensorAccess;
-            out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing;
-            out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing;
-            out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind;
-            out_ext->tensors = in_ext->tensors;
+            VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR);
+            const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
+            out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
+            out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
+            out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
+            out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
         {
-            VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM);
-            const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM;
-            out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors;
+            VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
+            const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
+            out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
         {
-            VkPhysicalDeviceShaderFloat8FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT);
-            const VkPhysicalDeviceShaderFloat8FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT;
-            out_ext->shaderFloat8 = in_ext->shaderFloat8;
-            out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix;
+            VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM);
+            const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM;
+            out_ext->ycbcrDegamma = in_ext->ycbcrDegamma;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
         {
-            VkPhysicalDeviceDataGraphFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM);
-            const VkPhysicalDeviceDataGraphFeaturesARM *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM;
-            out_ext->dataGraph = in_ext->dataGraph;
-            out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind;
-            out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants;
-            out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer;
-            out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule;
+            VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT);
+            const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
+            out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
         {
-            VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC);
-            const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC;
-            out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode;
+            VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT);
+            const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT;
+            out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
         {
-            VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR);
-            const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR;
-            out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers;
+            VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
+            const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
+            out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
             out_header = (void *)out_ext;
             break;
         }
@@ -33703,19 +33703,19 @@ static void convert_VkFormatProperties2_win32_to_host(struct conversion_context
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
         {
-            VkSubpassResolvePerformanceQueryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
+            VkFormatProperties3 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
         {
-            VkFormatProperties3 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
+            VkSubpassResolvePerformanceQueryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -33750,15 +33750,6 @@ static void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
-        {
-            VkSubpassResolvePerformanceQueryEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT);
-            const VkSubpassResolvePerformanceQueryEXT *in_ext = (const VkSubpassResolvePerformanceQueryEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
-            out_ext->optimal = in_ext->optimal;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
         {
             VkFormatProperties332 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3);
@@ -33770,6 +33761,15 @@ static void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
+        {
+            VkSubpassResolvePerformanceQueryEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT);
+            const VkSubpassResolvePerformanceQueryEXT *in_ext = (const VkSubpassResolvePerformanceQueryEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
+            out_ext->optimal = in_ext->optimal;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM:
         {
             VkTensorFormatPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM);
@@ -33862,13 +33862,15 @@ static void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conver
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
         {
-            VkPhysicalDeviceExternalImageFormatInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceExternalImageFormatInfo32 *in_ext = (const VkPhysicalDeviceExternalImageFormatInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
+            VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
             out_ext->pNext = NULL;
-            out_ext->handleType = in_ext->handleType;
+            out_ext->flags = in_ext->flags;
+            out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
+            out_ext->pFixedRateFlags = UlongToPtr(in_ext->pFixedRateFlags);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -33896,49 +33898,47 @@ static void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conver
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
         {
-            VkPhysicalDeviceImageViewImageFormatInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *in_ext = (const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT;
+            VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
             out_ext->pNext = NULL;
-            out_ext->imageViewType = in_ext->imageViewType;
+            out_ext->usage = in_ext->usage;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
         {
-            VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkVideoProfileListInfoKHR32 *in_ext = (const VkVideoProfileListInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
+            VkPhysicalDeviceExternalImageFormatInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceExternalImageFormatInfo32 *in_ext = (const VkPhysicalDeviceExternalImageFormatInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
             out_ext->pNext = NULL;
-            out_ext->profileCount = in_ext->profileCount;
-            out_ext->pProfiles = convert_VkVideoProfileInfoKHR_array_win32_to_host(ctx, (const VkVideoProfileInfoKHR32 *)UlongToPtr(in_ext->pProfiles), in_ext->profileCount);
+            out_ext->handleType = in_ext->handleType;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
         {
-            VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
+            VkPhysicalDeviceImageViewImageFormatInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *in_ext = (const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
-            out_ext->pFixedRateFlags = UlongToPtr(in_ext->pFixedRateFlags);
+            out_ext->imageViewType = in_ext->imageViewType;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
         {
-            VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
+            VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoProfileListInfoKHR32 *in_ext = (const VkVideoProfileListInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->usage = in_ext->usage;
+            out_ext->profileCount = in_ext->profileCount;
+            out_ext->pProfiles = convert_VkVideoProfileInfoKHR_array_win32_to_host(ctx, (const VkVideoProfileInfoKHR32 *)UlongToPtr(in_ext->pProfiles), in_ext->profileCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -33973,24 +33973,6 @@ static void convert_VkImageFormatProperties2_win32_to_host(struct conversion_con
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
-        {
-            VkSamplerYcbcrConversionImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
-            out_ext->pNext = NULL;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
-        {
-            VkTextureLODGatherFormatPropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
-            out_ext->pNext = NULL;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
         {
             VkFilterCubicImageViewImageFormatPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -34018,10 +34000,28 @@ static void convert_VkImageFormatProperties2_win32_to_host(struct conversion_con
             out_header = (void *)out_ext;
             break;
         }
-        default:
-            FIXME("Unhandled sType %u.\n", in_header->sType);
-            break;
-        }
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+        {
+            VkSamplerYcbcrConversionImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
+            out_ext->pNext = NULL;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+        {
+            VkTextureLODGatherFormatPropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
+            out_ext->pNext = NULL;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        default:
+            FIXME("Unhandled sType %u.\n", in_header->sType);
+            break;
+        }
     }
 }

@@ -34047,24 +34047,6 @@ static void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatPr
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
-        {
-            VkSamplerYcbcrConversionImageFormatProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
-            const VkSamplerYcbcrConversionImageFormatProperties *in_ext = (const VkSamplerYcbcrConversionImageFormatProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
-            out_ext->combinedImageSamplerDescriptorCount = in_ext->combinedImageSamplerDescriptorCount;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
-        {
-            VkTextureLODGatherFormatPropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD);
-            const VkTextureLODGatherFormatPropertiesAMD *in_ext = (const VkTextureLODGatherFormatPropertiesAMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
-            out_ext->supportsTextureGatherLODBiasAMD = in_ext->supportsTextureGatherLODBiasAMD;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
         {
             VkFilterCubicImageViewImageFormatPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT);
@@ -34095,6 +34077,24 @@ static void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatPr
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+        {
+            VkSamplerYcbcrConversionImageFormatProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
+            const VkSamplerYcbcrConversionImageFormatProperties *in_ext = (const VkSamplerYcbcrConversionImageFormatProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
+            out_ext->combinedImageSamplerDescriptorCount = in_ext->combinedImageSamplerDescriptorCount;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+        {
+            VkTextureLODGatherFormatPropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD);
+            const VkTextureLODGatherFormatPropertiesAMD *in_ext = (const VkTextureLODGatherFormatPropertiesAMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
+            out_ext->supportsTextureGatherLODBiasAMD = in_ext->supportsTextureGatherLODBiasAMD;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             break;
         }
@@ -34404,523 +34404,525 @@ static void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
+            VkPhysicalDeviceAccelerationStructurePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceClusterAccelerationStructurePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV;
+            VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
         {
-            VkPhysicalDeviceMultiDrawPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
+            VkPhysicalDeviceClusterAccelerationStructurePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
         {
-            VkPhysicalDevicePushDescriptorProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES;
+            VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceDriverProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+            VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceIDProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
+            VkPhysicalDeviceConservativeRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
         {
-            VkPhysicalDeviceMultiviewProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
+            VkPhysicalDeviceCooperativeMatrix2PropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceDiscardRectanglePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
+            VkPhysicalDeviceCooperativeMatrixPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
         {
-            VkPhysicalDeviceSubgroupProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
+            VkPhysicalDeviceCooperativeMatrixPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
         {
-            VkPhysicalDevicePointClippingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
+            VkPhysicalDeviceCooperativeVectorPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
         {
-            VkPhysicalDeviceProtectedMemoryProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
+            VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceSamplerFilterMinmaxProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
+            VkPhysicalDeviceCustomBorderColorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
         {
-            VkPhysicalDeviceSampleLocationsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
+            VkPhysicalDeviceDepthStencilResolveProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
+            VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceInlineUniformBlockProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
+            VkPhysicalDeviceDescriptorBufferPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
         {
-            VkPhysicalDeviceMaintenance3Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
+            VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM;
             out_ext->pNext = NULL;
+            out_ext->tensorCaptureReplayDescriptorDataSize = in_ext->tensorCaptureReplayDescriptorDataSize;
+            out_ext->tensorViewCaptureReplayDescriptorDataSize = in_ext->tensorViewCaptureReplayDescriptorDataSize;
+            out_ext->tensorDescriptorSize = in_ext->tensorDescriptorSize;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
         {
-            VkPhysicalDeviceMaintenance4Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
+            VkPhysicalDeviceDescriptorIndexingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceMaintenance5Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES;
+            VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
         {
-            VkPhysicalDeviceMaintenance6Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES;
+            VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceMaintenance9PropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR;
+            VkPhysicalDeviceDiscardRectanglePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
         {
-            VkPhysicalDeviceFloatControlsProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
+            VkPhysicalDeviceDriverProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceExternalMemoryHostPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
+            VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
         {
-            VkPhysicalDeviceConservativeRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
+            VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceShaderCorePropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
+            VkPhysicalDeviceExternalMemoryHostPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
         {
-            VkPhysicalDeviceShaderCoreProperties2AMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
+            VkPhysicalDeviceFloatControlsProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceDescriptorIndexingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
+            VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE:
         {
-            VkPhysicalDeviceTimelineSemaphoreProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
+            VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
+            VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceVertexAttributeDivisorProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES;
+            VkPhysicalDeviceFragmentDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
         {
-            VkPhysicalDevicePCIBusInfoPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
+            VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
         {
-            VkPhysicalDeviceDepthStencilResolveProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
+            VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceTransformFeedbackPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
+            VkPhysicalDeviceFragmentShadingRatePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR;
-            out_ext->pNext = NULL;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
-        {
-            VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
+            VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES:
         {
-            VkPhysicalDeviceMemoryDecompressionPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
+            VkPhysicalDeviceHostImageCopyProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceHostImageCopyProperties32 *in_ext = (const VkPhysicalDeviceHostImageCopyProperties32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES;
             out_ext->pNext = NULL;
+            out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount;
+            out_ext->pCopySrcLayouts = UlongToPtr(in_ext->pCopySrcLayouts);
+            out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount;
+            out_ext->pCopyDstLayouts = UlongToPtr(in_ext->pCopyDstLayouts);
+            memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t));
+            out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
         {
-            VkPhysicalDeviceShadingRateImagePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
+            VkPhysicalDeviceIDProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
         {
-            VkPhysicalDeviceMeshShaderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
+            VkPhysicalDeviceImageAlignmentControlPropertiesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
         {
-            VkPhysicalDeviceMeshShaderPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
+            VkPhysicalDeviceImageProcessing2PropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
         {
-            VkPhysicalDeviceAccelerationStructurePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
+            VkPhysicalDeviceImageProcessingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
         {
-            VkPhysicalDeviceRayTracingPipelinePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
+            VkPhysicalDeviceInlineUniformBlockProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
         {
-            VkPhysicalDeviceRayTracingPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
+            VkPhysicalDeviceLayeredDriverPropertiesMSFT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceFragmentDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
+            VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES:
         {
-            VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
+            VkPhysicalDeviceLineRasterizationProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
         {
-            VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT;
+            VkPhysicalDeviceMaintenance3Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
         {
-            VkPhysicalDeviceCooperativeMatrixPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
+            VkPhysicalDeviceMaintenance4Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
         {
-            VkPhysicalDevicePerformanceQueryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
+            VkPhysicalDeviceMaintenance5Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES:
         {
-            VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
+            VkPhysicalDeviceMaintenance6Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceTexelBufferAlignmentProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
+            VkPhysicalDeviceMaintenance9PropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceSubgroupSizeControlProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
+            VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
         {
-            VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
+            VkPhysicalDeviceMemoryDecompressionPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI;
+            VkPhysicalDeviceMeshShaderPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
         {
-            VkPhysicalDeviceLineRasterizationProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;
+            VkPhysicalDeviceMeshShaderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceVulkan11Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
+            VkPhysicalDeviceMultiDrawPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
         {
-            VkPhysicalDeviceVulkan12Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
+            VkPhysicalDeviceMultiviewProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceVulkan13Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
+            VkPhysicalDeviceNestedCommandBufferPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceVulkan14Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES;
+            VkPhysicalDeviceOpacityMicromapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
         {
-            VkPhysicalDeviceCustomBorderColorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
+            VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
+            VkPhysicalDevicePCIBusInfoPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -34935,367 +34937,365 @@ static void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceRobustness2PropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR;
+            VkPhysicalDevicePerformanceQueryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceFragmentShadingRatePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
+            VkPhysicalDevicePipelineBinaryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES:
         {
-            VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
+            VkPhysicalDevicePipelineRobustnessProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
         {
-            VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT;
+            VkPhysicalDevicePointClippingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT;
+            VkPhysicalDeviceProtectedMemoryProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceHostImageCopyProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceHostImageCopyProperties32 *in_ext = (const VkPhysicalDeviceHostImageCopyProperties32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES;
+            VkPhysicalDeviceProvokingVertexPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
             out_ext->pNext = NULL;
-            out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount;
-            out_ext->pCopySrcLayouts = UlongToPtr(in_ext->pCopySrcLayouts);
-            out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount;
-            out_ext->pCopyDstLayouts = UlongToPtr(in_ext->pCopyDstLayouts);
-            memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t));
-            out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES:
         {
-            VkPhysicalDeviceProvokingVertexPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
+            VkPhysicalDevicePushDescriptorProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
         {
-            VkPhysicalDeviceDescriptorBufferPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
+            VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
+            VkPhysicalDeviceRayTracingPipelinePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
         {
-            VkPhysicalDeviceShaderIntegerDotProductProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
+            VkPhysicalDeviceRayTracingPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
         {
-            VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
+            VkPhysicalDeviceRenderPassStripedPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
         {
-            VkPhysicalDevicePipelineBinaryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR;
+            VkPhysicalDeviceRobustness2PropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
+            VkPhysicalDeviceSampleLocationsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
         {
-            VkPhysicalDeviceNestedCommandBufferPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT;
+            VkPhysicalDeviceSamplerFilterMinmaxProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
         {
-            VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
+            VkPhysicalDeviceSchedulingControlsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
         {
-            VkPhysicalDeviceOpacityMicromapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
+            VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
         {
-            VkPhysicalDevicePipelineRobustnessProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES;
+            VkPhysicalDeviceShaderCoreProperties2AMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
         {
-            VkPhysicalDeviceImageProcessingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
+            VkPhysicalDeviceShaderCorePropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
         {
-            VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
+            VkPhysicalDeviceShaderCorePropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
         {
-            VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
+            VkPhysicalDeviceShaderIntegerDotProductProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
+            VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV;
+            VkPhysicalDeviceShaderObjectPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
         {
-            VkPhysicalDeviceShaderCorePropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM;
+            VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceShaderObjectPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
+            VkPhysicalDeviceShaderTileImagePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
         {
-            VkPhysicalDeviceShaderTileImagePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
+            VkPhysicalDeviceShadingRateImagePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
         {
-            VkPhysicalDeviceCooperativeMatrixPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR;
+            VkPhysicalDeviceSubgroupProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
         {
-            VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32 *in_ext = (const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM;
+            VkPhysicalDeviceSubgroupSizeControlProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
             out_ext->pNext = NULL;
-            out_ext->queueSubmitBoundary = in_ext->queueSubmitBoundary;
-            out_ext->tileBufferTransfers = in_ext->tileBufferTransfers;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
         {
-            VkPhysicalDeviceImageProcessing2PropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM;
+            VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
         {
-            VkPhysicalDeviceLayeredDriverPropertiesMSFT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT;
+            VkPhysicalDeviceTensorPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
         {
-            VkPhysicalDeviceSchedulingControlsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM;
+            VkPhysicalDeviceTexelBufferAlignmentProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
         {
-            VkPhysicalDeviceRenderPassStripedPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM;
+            VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32 *in_ext = (const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM;
             out_ext->pNext = NULL;
+            out_ext->queueSubmitBoundary = in_ext->queueSubmitBoundary;
+            out_ext->tileBufferTransfers = in_ext->tileBufferTransfers;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
         {
-            VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT;
+            VkPhysicalDeviceTileShadingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
         {
-            VkPhysicalDeviceImageAlignmentControlPropertiesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA;
+            VkPhysicalDeviceTimelineSemaphoreProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceCooperativeMatrix2PropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV;
+            VkPhysicalDeviceTransformFeedbackPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES:
         {
-            VkPhysicalDeviceCooperativeVectorPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV;
+            VkPhysicalDeviceVertexAttributeDivisorProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceTileShadingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM;
+            VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
         {
-            VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE;
+            VkPhysicalDeviceVulkan11Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
         {
-            VkPhysicalDeviceTensorPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM;
+            VkPhysicalDeviceVulkan12Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
         {
-            VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM;
+            VkPhysicalDeviceVulkan13Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
+            out_ext->pNext = NULL;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:
+        {
+            VkPhysicalDeviceVulkan14Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES;
             out_ext->pNext = NULL;
-            out_ext->tensorCaptureReplayDescriptorDataSize = in_ext->tensorCaptureReplayDescriptorDataSize;
-            out_ext->tensorViewCaptureReplayDescriptorDataSize = in_ext->tensorViewCaptureReplayDescriptorDataSize;
-            out_ext->tensorDescriptorSize = in_ext->tensorDescriptorSize;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -35320,20 +35320,33 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV);
-            const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
-            out_ext->maxGraphicsShaderGroupCount = in_ext->maxGraphicsShaderGroupCount;
-            out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount;
-            out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount;
-            out_ext->maxIndirectCommandsStreamCount = in_ext->maxIndirectCommandsStreamCount;
-            out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset;
-            out_ext->maxIndirectCommandsStreamStride = in_ext->maxIndirectCommandsStreamStride;
-            out_ext->minSequencesCountBufferOffsetAlignment = in_ext->minSequencesCountBufferOffsetAlignment;
-            out_ext->minSequencesIndexBufferOffsetAlignment = in_ext->minSequencesIndexBufferOffsetAlignment;
-            out_ext->minIndirectCommandsBufferOffsetAlignment = in_ext->minIndirectCommandsBufferOffsetAlignment;
+            VkPhysicalDeviceAccelerationStructurePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR);
+            const VkPhysicalDeviceAccelerationStructurePropertiesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructurePropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
+            out_ext->maxGeometryCount = in_ext->maxGeometryCount;
+            out_ext->maxInstanceCount = in_ext->maxInstanceCount;
+            out_ext->maxPrimitiveCount = in_ext->maxPrimitiveCount;
+            out_ext->maxPerStageDescriptorAccelerationStructures = in_ext->maxPerStageDescriptorAccelerationStructures;
+            out_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures = in_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
+            out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
+            out_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures = in_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures;
+            out_ext->minAccelerationStructureScratchOffsetAlignment = in_ext->minAccelerationStructureScratchOffsetAlignment;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+        {
+            VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT);
+            const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
+            out_ext->advancedBlendMaxColorAttachments = in_ext->advancedBlendMaxColorAttachments;
+            out_ext->advancedBlendIndependentBlend = in_ext->advancedBlendIndependentBlend;
+            out_ext->advancedBlendNonPremultipliedSrcColor = in_ext->advancedBlendNonPremultipliedSrcColor;
+            out_ext->advancedBlendNonPremultipliedDstColor = in_ext->advancedBlendNonPremultipliedDstColor;
+            out_ext->advancedBlendCorrelatedOverlap = in_ext->advancedBlendCorrelatedOverlap;
+            out_ext->advancedBlendAllOperations = in_ext->advancedBlendAllOperations;
             out_header = (void *)out_ext;
             break;
         }
@@ -35353,200 +35366,292 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
         {
-            VkPhysicalDeviceMultiDrawPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT);
-            const VkPhysicalDeviceMultiDrawPropertiesEXT *in_ext = (const VkPhysicalDeviceMultiDrawPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
-            out_ext->maxMultiDrawCount = in_ext->maxMultiDrawCount;
+            VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI);
+            const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI;
+            memcpy(out_ext->maxWorkGroupCount, in_ext->maxWorkGroupCount, 3 * sizeof(uint32_t));
+            memcpy(out_ext->maxWorkGroupSize, in_ext->maxWorkGroupSize, 3 * sizeof(uint32_t));
+            out_ext->maxOutputClusterCount = in_ext->maxOutputClusterCount;
+            out_ext->indirectBufferOffsetAlignment = in_ext->indirectBufferOffsetAlignment;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR:
         {
-            VkPhysicalDevicePushDescriptorProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES);
-            const VkPhysicalDevicePushDescriptorProperties *in_ext = (const VkPhysicalDevicePushDescriptorProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES;
-            out_ext->maxPushDescriptors = in_ext->maxPushDescriptors;
+            VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR);
+            const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR;
+            out_ext->meshAndTaskShaderDerivatives = in_ext->meshAndTaskShaderDerivatives;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceDriverProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
-            const VkPhysicalDeviceDriverProperties *in_ext = (const VkPhysicalDeviceDriverProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
-            out_ext->driverID = in_ext->driverID;
-            memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
-            memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
-            out_ext->conformanceVersion = in_ext->conformanceVersion;
+            VkPhysicalDeviceConservativeRasterizationPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT);
+            const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
+            out_ext->primitiveOverestimationSize = in_ext->primitiveOverestimationSize;
+            out_ext->maxExtraPrimitiveOverestimationSize = in_ext->maxExtraPrimitiveOverestimationSize;
+            out_ext->extraPrimitiveOverestimationSizeGranularity = in_ext->extraPrimitiveOverestimationSizeGranularity;
+            out_ext->primitiveUnderestimation = in_ext->primitiveUnderestimation;
+            out_ext->conservativePointAndLineRasterization = in_ext->conservativePointAndLineRasterization;
+            out_ext->degenerateTrianglesRasterized = in_ext->degenerateTrianglesRasterized;
+            out_ext->degenerateLinesRasterized = in_ext->degenerateLinesRasterized;
+            out_ext->fullyCoveredFragmentShaderInputVariable = in_ext->fullyCoveredFragmentShaderInputVariable;
+            out_ext->conservativeRasterizationPostDepthCoverage = in_ext->conservativeRasterizationPostDepthCoverage;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
         {
-            VkPhysicalDeviceIDProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
-            const VkPhysicalDeviceIDProperties *in_ext = (const VkPhysicalDeviceIDProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
-            memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
-            memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
-            memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
-            out_ext->deviceNodeMask = in_ext->deviceNodeMask;
-            out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
+            VkPhysicalDeviceCooperativeMatrix2PropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV);
+            const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV;
+            out_ext->cooperativeMatrixWorkgroupScopeMaxWorkgroupSize = in_ext->cooperativeMatrixWorkgroupScopeMaxWorkgroupSize;
+            out_ext->cooperativeMatrixFlexibleDimensionsMaxDimension = in_ext->cooperativeMatrixFlexibleDimensionsMaxDimension;
+            out_ext->cooperativeMatrixWorkgroupScopeReservedSharedMemory = in_ext->cooperativeMatrixWorkgroupScopeReservedSharedMemory;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceMultiviewProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
-            const VkPhysicalDeviceMultiviewProperties *in_ext = (const VkPhysicalDeviceMultiviewProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
-            out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
-            out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
+            VkPhysicalDeviceCooperativeMatrixPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR);
+            const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR;
+            out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
         {
-            VkPhysicalDeviceDiscardRectanglePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT);
-            const VkPhysicalDeviceDiscardRectanglePropertiesEXT *in_ext = (const VkPhysicalDeviceDiscardRectanglePropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
-            out_ext->maxDiscardRectangles = in_ext->maxDiscardRectangles;
+            VkPhysicalDeviceCooperativeMatrixPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV);
+            const VkPhysicalDeviceCooperativeMatrixPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
+            out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
         {
-            VkPhysicalDeviceSubgroupProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
-            const VkPhysicalDeviceSubgroupProperties *in_ext = (const VkPhysicalDeviceSubgroupProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
-            out_ext->subgroupSize = in_ext->subgroupSize;
-            out_ext->supportedStages = in_ext->supportedStages;
-            out_ext->supportedOperations = in_ext->supportedOperations;
-            out_ext->quadOperationsInAllStages = in_ext->quadOperationsInAllStages;
+            VkPhysicalDeviceCooperativeVectorPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV);
+            const VkPhysicalDeviceCooperativeVectorPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeVectorPropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV;
+            out_ext->cooperativeVectorSupportedStages = in_ext->cooperativeVectorSupportedStages;
+            out_ext->cooperativeVectorTrainingFloat16Accumulation = in_ext->cooperativeVectorTrainingFloat16Accumulation;
+            out_ext->cooperativeVectorTrainingFloat32Accumulation = in_ext->cooperativeVectorTrainingFloat32Accumulation;
+            out_ext->maxCooperativeVectorComponents = in_ext->maxCooperativeVectorComponents;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
         {
-            VkPhysicalDevicePointClippingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
-            const VkPhysicalDevicePointClippingProperties *in_ext = (const VkPhysicalDevicePointClippingProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
-            out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
+            VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV);
+            const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
+            out_ext->supportedQueues = in_ext->supportedQueues;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceProtectedMemoryProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
-            const VkPhysicalDeviceProtectedMemoryProperties *in_ext = (const VkPhysicalDeviceProtectedMemoryProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
-            out_ext->protectedNoFault = in_ext->protectedNoFault;
+            VkPhysicalDeviceCustomBorderColorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT);
+            const VkPhysicalDeviceCustomBorderColorPropertiesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
+            out_ext->maxCustomBorderColorSamplers = in_ext->maxCustomBorderColorSamplers;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
         {
-            VkPhysicalDeviceSamplerFilterMinmaxProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
-            const VkPhysicalDeviceSamplerFilterMinmaxProperties *in_ext = (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
-            out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
-            out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
+            VkPhysicalDeviceDepthStencilResolveProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
+            const VkPhysicalDeviceDepthStencilResolveProperties *in_ext = (const VkPhysicalDeviceDepthStencilResolveProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
+            out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
+            out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
+            out_ext->independentResolveNone = in_ext->independentResolveNone;
+            out_ext->independentResolve = in_ext->independentResolve;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceSampleLocationsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT);
-            const VkPhysicalDeviceSampleLocationsPropertiesEXT *in_ext = (const VkPhysicalDeviceSampleLocationsPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
-            out_ext->sampleLocationSampleCounts = in_ext->sampleLocationSampleCounts;
-            out_ext->maxSampleLocationGridSize = in_ext->maxSampleLocationGridSize;
-            memcpy(out_ext->sampleLocationCoordinateRange, in_ext->sampleLocationCoordinateRange, 2 * sizeof(float));
-            out_ext->sampleLocationSubPixelBits = in_ext->sampleLocationSubPixelBits;
-            out_ext->variableSampleLocations = in_ext->variableSampleLocations;
+            VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT);
+            const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
+            out_ext->combinedImageSamplerDensityMapDescriptorSize = in_ext->combinedImageSamplerDensityMapDescriptorSize;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT);
-            const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
-            out_ext->advancedBlendMaxColorAttachments = in_ext->advancedBlendMaxColorAttachments;
-            out_ext->advancedBlendIndependentBlend = in_ext->advancedBlendIndependentBlend;
-            out_ext->advancedBlendNonPremultipliedSrcColor = in_ext->advancedBlendNonPremultipliedSrcColor;
-            out_ext->advancedBlendNonPremultipliedDstColor = in_ext->advancedBlendNonPremultipliedDstColor;
-            out_ext->advancedBlendCorrelatedOverlap = in_ext->advancedBlendCorrelatedOverlap;
-            out_ext->advancedBlendAllOperations = in_ext->advancedBlendAllOperations;
+            VkPhysicalDeviceDescriptorBufferPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT);
+            const VkPhysicalDeviceDescriptorBufferPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
+            out_ext->combinedImageSamplerDescriptorSingleArray = in_ext->combinedImageSamplerDescriptorSingleArray;
+            out_ext->bufferlessPushDescriptors = in_ext->bufferlessPushDescriptors;
+            out_ext->allowSamplerImageViewPostSubmitCreation = in_ext->allowSamplerImageViewPostSubmitCreation;
+            out_ext->descriptorBufferOffsetAlignment = in_ext->descriptorBufferOffsetAlignment;
+            out_ext->maxDescriptorBufferBindings = in_ext->maxDescriptorBufferBindings;
+            out_ext->maxResourceDescriptorBufferBindings = in_ext->maxResourceDescriptorBufferBindings;
+            out_ext->maxSamplerDescriptorBufferBindings = in_ext->maxSamplerDescriptorBufferBindings;
+            out_ext->maxEmbeddedImmutableSamplerBindings = in_ext->maxEmbeddedImmutableSamplerBindings;
+            out_ext->maxEmbeddedImmutableSamplers = in_ext->maxEmbeddedImmutableSamplers;
+            out_ext->bufferCaptureReplayDescriptorDataSize = in_ext->bufferCaptureReplayDescriptorDataSize;
+            out_ext->imageCaptureReplayDescriptorDataSize = in_ext->imageCaptureReplayDescriptorDataSize;
+            out_ext->imageViewCaptureReplayDescriptorDataSize = in_ext->imageViewCaptureReplayDescriptorDataSize;
+            out_ext->samplerCaptureReplayDescriptorDataSize = in_ext->samplerCaptureReplayDescriptorDataSize;
+            out_ext->accelerationStructureCaptureReplayDescriptorDataSize = in_ext->accelerationStructureCaptureReplayDescriptorDataSize;
+            out_ext->samplerDescriptorSize = in_ext->samplerDescriptorSize;
+            out_ext->combinedImageSamplerDescriptorSize = in_ext->combinedImageSamplerDescriptorSize;
+            out_ext->sampledImageDescriptorSize = in_ext->sampledImageDescriptorSize;
+            out_ext->storageImageDescriptorSize = in_ext->storageImageDescriptorSize;
+            out_ext->uniformTexelBufferDescriptorSize = in_ext->uniformTexelBufferDescriptorSize;
+            out_ext->robustUniformTexelBufferDescriptorSize = in_ext->robustUniformTexelBufferDescriptorSize;
+            out_ext->storageTexelBufferDescriptorSize = in_ext->storageTexelBufferDescriptorSize;
+            out_ext->robustStorageTexelBufferDescriptorSize = in_ext->robustStorageTexelBufferDescriptorSize;
+            out_ext->uniformBufferDescriptorSize = in_ext->uniformBufferDescriptorSize;
+            out_ext->robustUniformBufferDescriptorSize = in_ext->robustUniformBufferDescriptorSize;
+            out_ext->storageBufferDescriptorSize = in_ext->storageBufferDescriptorSize;
+            out_ext->robustStorageBufferDescriptorSize = in_ext->robustStorageBufferDescriptorSize;
+            out_ext->inputAttachmentDescriptorSize = in_ext->inputAttachmentDescriptorSize;
+            out_ext->accelerationStructureDescriptorSize = in_ext->accelerationStructureDescriptorSize;
+            out_ext->maxSamplerDescriptorBufferRange = in_ext->maxSamplerDescriptorBufferRange;
+            out_ext->maxResourceDescriptorBufferRange = in_ext->maxResourceDescriptorBufferRange;
+            out_ext->samplerDescriptorBufferAddressSpaceSize = in_ext->samplerDescriptorBufferAddressSpaceSize;
+            out_ext->resourceDescriptorBufferAddressSpaceSize = in_ext->resourceDescriptorBufferAddressSpaceSize;
+            out_ext->descriptorBufferAddressSpaceSize = in_ext->descriptorBufferAddressSpaceSize;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
         {
-            VkPhysicalDeviceInlineUniformBlockProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES);
-            const VkPhysicalDeviceInlineUniformBlockProperties *in_ext = (const VkPhysicalDeviceInlineUniformBlockProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
-            out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
-            out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
-            out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
-            out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
-            out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+            VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM);
+            const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM;
+            out_ext->tensorCaptureReplayDescriptorDataSize = in_ext->tensorCaptureReplayDescriptorDataSize;
+            out_ext->tensorViewCaptureReplayDescriptorDataSize = in_ext->tensorViewCaptureReplayDescriptorDataSize;
+            out_ext->tensorDescriptorSize = in_ext->tensorDescriptorSize;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
         {
-            VkPhysicalDeviceMaintenance3Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
-            const VkPhysicalDeviceMaintenance3Properties *in_ext = (const VkPhysicalDeviceMaintenance3Properties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
-            out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
-            out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
+            VkPhysicalDeviceDescriptorIndexingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
+            const VkPhysicalDeviceDescriptorIndexingProperties *in_ext = (const VkPhysicalDeviceDescriptorIndexingProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
+            out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
+            out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
+            out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
+            out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
+            out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
+            out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
+            out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
+            out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
+            out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
+            out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+            out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+            out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
+            out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
+            out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
+            out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
+            out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
+            out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
+            out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+            out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
+            out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+            out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
+            out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
+            out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceMaintenance4Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES);
-            const VkPhysicalDeviceMaintenance4Properties *in_ext = (const VkPhysicalDeviceMaintenance4Properties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
-            out_ext->maxBufferSize = in_ext->maxBufferSize;
+            VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT);
+            const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT;
+            out_ext->maxIndirectPipelineCount = in_ext->maxIndirectPipelineCount;
+            out_ext->maxIndirectShaderObjectCount = in_ext->maxIndirectShaderObjectCount;
+            out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount;
+            out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount;
+            out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset;
+            out_ext->maxIndirectCommandsIndirectStride = in_ext->maxIndirectCommandsIndirectStride;
+            out_ext->supportedIndirectCommandsInputModes = in_ext->supportedIndirectCommandsInputModes;
+            out_ext->supportedIndirectCommandsShaderStages = in_ext->supportedIndirectCommandsShaderStages;
+            out_ext->supportedIndirectCommandsShaderStagesPipelineBinding = in_ext->supportedIndirectCommandsShaderStagesPipelineBinding;
+            out_ext->supportedIndirectCommandsShaderStagesShaderBinding = in_ext->supportedIndirectCommandsShaderStagesShaderBinding;
+            out_ext->deviceGeneratedCommandsTransformFeedback = in_ext->deviceGeneratedCommandsTransformFeedback;
+            out_ext->deviceGeneratedCommandsMultiDrawIndirectCount = in_ext->deviceGeneratedCommandsMultiDrawIndirectCount;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
         {
-            VkPhysicalDeviceMaintenance5Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES);
-            const VkPhysicalDeviceMaintenance5Properties *in_ext = (const VkPhysicalDeviceMaintenance5Properties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES;
-            out_ext->earlyFragmentMultisampleCoverageAfterSampleCounting = in_ext->earlyFragmentMultisampleCoverageAfterSampleCounting;
-            out_ext->earlyFragmentSampleMaskTestBeforeSampleCounting = in_ext->earlyFragmentSampleMaskTestBeforeSampleCounting;
-            out_ext->depthStencilSwizzleOneSupport = in_ext->depthStencilSwizzleOneSupport;
-            out_ext->polygonModePointSize = in_ext->polygonModePointSize;
-            out_ext->nonStrictSinglePixelWideLinesUseParallelogram = in_ext->nonStrictSinglePixelWideLinesUseParallelogram;
-            out_ext->nonStrictWideLinesUseParallelogram = in_ext->nonStrictWideLinesUseParallelogram;
+            VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV);
+            const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
+            out_ext->maxGraphicsShaderGroupCount = in_ext->maxGraphicsShaderGroupCount;
+            out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount;
+            out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount;
+            out_ext->maxIndirectCommandsStreamCount = in_ext->maxIndirectCommandsStreamCount;
+            out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset;
+            out_ext->maxIndirectCommandsStreamStride = in_ext->maxIndirectCommandsStreamStride;
+            out_ext->minSequencesCountBufferOffsetAlignment = in_ext->minSequencesCountBufferOffsetAlignment;
+            out_ext->minSequencesIndexBufferOffsetAlignment = in_ext->minSequencesIndexBufferOffsetAlignment;
+            out_ext->minIndirectCommandsBufferOffsetAlignment = in_ext->minIndirectCommandsBufferOffsetAlignment;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceMaintenance6Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES);
-            const VkPhysicalDeviceMaintenance6Properties *in_ext = (const VkPhysicalDeviceMaintenance6Properties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES;
-            out_ext->blockTexelViewCompatibleMultipleLayers = in_ext->blockTexelViewCompatibleMultipleLayers;
-            out_ext->maxCombinedImageSamplerDescriptorCount = in_ext->maxCombinedImageSamplerDescriptorCount;
-            out_ext->fragmentShadingRateClampCombinerInputs = in_ext->fragmentShadingRateClampCombinerInputs;
+            VkPhysicalDeviceDiscardRectanglePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT);
+            const VkPhysicalDeviceDiscardRectanglePropertiesEXT *in_ext = (const VkPhysicalDeviceDiscardRectanglePropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
+            out_ext->maxDiscardRectangles = in_ext->maxDiscardRectangles;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
         {
-            VkPhysicalDeviceMaintenance9PropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR);
-            const VkPhysicalDeviceMaintenance9PropertiesKHR *in_ext = (const VkPhysicalDeviceMaintenance9PropertiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR;
-            out_ext->image2DViewOf3DSparse = in_ext->image2DViewOf3DSparse;
-            out_ext->defaultVertexAttributeValue = in_ext->defaultVertexAttributeValue;
-            out_header = (void *)out_ext;
+            VkPhysicalDeviceDriverProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
+            const VkPhysicalDeviceDriverProperties *in_ext = (const VkPhysicalDeviceDriverProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+            out_ext->driverID = in_ext->driverID;
+            memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
+            memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
+            out_ext->conformanceVersion = in_ext->conformanceVersion;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
+        {
+            VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT);
+            const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
+            out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
+        {
+            VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV);
+            const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV;
+            out_ext->extendedSparseAddressSpaceSize = in_ext->extendedSparseAddressSpaceSize;
+            out_ext->extendedSparseImageUsageFlags = in_ext->extendedSparseImageUsageFlags;
+            out_ext->extendedSparseBufferUsageFlags = in_ext->extendedSparseBufferUsageFlags;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+        {
+            VkPhysicalDeviceExternalMemoryHostPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT);
+            const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *in_ext = (const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
+            out_ext->minImportedHostPointerAlignment = in_ext->minImportedHostPointerAlignment;
+            out_header = (void *)out_ext;
             break;
         }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
@@ -35574,222 +35679,267 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceExternalMemoryHostPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT);
-            const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *in_ext = (const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
-            out_ext->minImportedHostPointerAlignment = in_ext->minImportedHostPointerAlignment;
+            VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT);
+            const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
+            out_ext->subsampledLoads = in_ext->subsampledLoads;
+            out_ext->subsampledCoarseReconstructionEarlyAccess = in_ext->subsampledCoarseReconstructionEarlyAccess;
+            out_ext->maxSubsampledArrayLayers = in_ext->maxSubsampledArrayLayers;
+            out_ext->maxDescriptorSetSubsampledSamplers = in_ext->maxDescriptorSetSubsampledSamplers;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE:
         {
-            VkPhysicalDeviceConservativeRasterizationPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT);
-            const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
-            out_ext->primitiveOverestimationSize = in_ext->primitiveOverestimationSize;
-            out_ext->maxExtraPrimitiveOverestimationSize = in_ext->maxExtraPrimitiveOverestimationSize;
-            out_ext->extraPrimitiveOverestimationSizeGranularity = in_ext->extraPrimitiveOverestimationSizeGranularity;
-            out_ext->primitiveUnderestimation = in_ext->primitiveUnderestimation;
-            out_ext->conservativePointAndLineRasterization = in_ext->conservativePointAndLineRasterization;
-            out_ext->degenerateTrianglesRasterized = in_ext->degenerateTrianglesRasterized;
-            out_ext->degenerateLinesRasterized = in_ext->degenerateLinesRasterized;
-            out_ext->fullyCoveredFragmentShaderInputVariable = in_ext->fullyCoveredFragmentShaderInputVariable;
-            out_ext->conservativeRasterizationPostDepthCoverage = in_ext->conservativeRasterizationPostDepthCoverage;
+            VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE);
+            const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *in_ext = (const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE;
+            out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceShaderCorePropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD);
-            const VkPhysicalDeviceShaderCorePropertiesAMD *in_ext = (const VkPhysicalDeviceShaderCorePropertiesAMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
-            out_ext->shaderEngineCount = in_ext->shaderEngineCount;
-            out_ext->shaderArraysPerEngineCount = in_ext->shaderArraysPerEngineCount;
-            out_ext->computeUnitsPerShaderArray = in_ext->computeUnitsPerShaderArray;
-            out_ext->simdPerComputeUnit = in_ext->simdPerComputeUnit;
-            out_ext->wavefrontsPerSimd = in_ext->wavefrontsPerSimd;
-            out_ext->wavefrontSize = in_ext->wavefrontSize;
-            out_ext->sgprsPerSimd = in_ext->sgprsPerSimd;
-            out_ext->minSgprAllocation = in_ext->minSgprAllocation;
-            out_ext->maxSgprAllocation = in_ext->maxSgprAllocation;
-            out_ext->sgprAllocationGranularity = in_ext->sgprAllocationGranularity;
-            out_ext->vgprsPerSimd = in_ext->vgprsPerSimd;
-            out_ext->minVgprAllocation = in_ext->minVgprAllocation;
-            out_ext->maxVgprAllocation = in_ext->maxVgprAllocation;
-            out_ext->vgprAllocationGranularity = in_ext->vgprAllocationGranularity;
+            VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT);
+            const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT;
+            out_ext->fragmentDensityOffsetGranularity = in_ext->fragmentDensityOffsetGranularity;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceShaderCoreProperties2AMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD);
-            const VkPhysicalDeviceShaderCoreProperties2AMD *in_ext = (const VkPhysicalDeviceShaderCoreProperties2AMD *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
-            out_ext->shaderCoreFeatures = in_ext->shaderCoreFeatures;
-            out_ext->activeComputeUnitCount = in_ext->activeComputeUnitCount;
+            VkPhysicalDeviceFragmentDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT);
+            const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
+            out_ext->minFragmentDensityTexelSize = in_ext->minFragmentDensityTexelSize;
+            out_ext->maxFragmentDensityTexelSize = in_ext->maxFragmentDensityTexelSize;
+            out_ext->fragmentDensityInvocations = in_ext->fragmentDensityInvocations;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceDescriptorIndexingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
-            const VkPhysicalDeviceDescriptorIndexingProperties *in_ext = (const VkPhysicalDeviceDescriptorIndexingProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
-            out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
-            out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
-            out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
-            out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
-            out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
-            out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
-            out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
-            out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
-            out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
-            out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
-            out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
-            out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
-            out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
-            out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
-            out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
-            out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
-            out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
-            out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
-            out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
-            out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
-            out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
-            out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
-            out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
+            VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR);
+            const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
+            out_ext->triStripVertexOrderIndependentOfProvokingVertex = in_ext->triStripVertexOrderIndependentOfProvokingVertex;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
         {
-            VkPhysicalDeviceTimelineSemaphoreProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
-            const VkPhysicalDeviceTimelineSemaphoreProperties *in_ext = (const VkPhysicalDeviceTimelineSemaphoreProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
-            out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
+            VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV);
+            const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
+            out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT);
-            const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
-            out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor;
+            VkPhysicalDeviceFragmentShadingRatePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR);
+            const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
+            out_ext->minFragmentShadingRateAttachmentTexelSize = in_ext->minFragmentShadingRateAttachmentTexelSize;
+            out_ext->maxFragmentShadingRateAttachmentTexelSize = in_ext->maxFragmentShadingRateAttachmentTexelSize;
+            out_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
+            out_ext->primitiveFragmentShadingRateWithMultipleViewports = in_ext->primitiveFragmentShadingRateWithMultipleViewports;
+            out_ext->layeredShadingRateAttachments = in_ext->layeredShadingRateAttachments;
+            out_ext->fragmentShadingRateNonTrivialCombinerOps = in_ext->fragmentShadingRateNonTrivialCombinerOps;
+            out_ext->maxFragmentSize = in_ext->maxFragmentSize;
+            out_ext->maxFragmentSizeAspectRatio = in_ext->maxFragmentSizeAspectRatio;
+            out_ext->maxFragmentShadingRateCoverageSamples = in_ext->maxFragmentShadingRateCoverageSamples;
+            out_ext->maxFragmentShadingRateRasterizationSamples = in_ext->maxFragmentShadingRateRasterizationSamples;
+            out_ext->fragmentShadingRateWithShaderDepthStencilWrites = in_ext->fragmentShadingRateWithShaderDepthStencilWrites;
+            out_ext->fragmentShadingRateWithSampleMask = in_ext->fragmentShadingRateWithSampleMask;
+            out_ext->fragmentShadingRateWithShaderSampleMask = in_ext->fragmentShadingRateWithShaderSampleMask;
+            out_ext->fragmentShadingRateWithConservativeRasterization = in_ext->fragmentShadingRateWithConservativeRasterization;
+            out_ext->fragmentShadingRateWithFragmentShaderInterlock = in_ext->fragmentShadingRateWithFragmentShaderInterlock;
+            out_ext->fragmentShadingRateWithCustomSampleLocations = in_ext->fragmentShadingRateWithCustomSampleLocations;
+            out_ext->fragmentShadingRateStrictMultiplyCombiner = in_ext->fragmentShadingRateStrictMultiplyCombiner;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceVertexAttributeDivisorProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES);
-            const VkPhysicalDeviceVertexAttributeDivisorProperties *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES;
-            out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor;
-            out_ext->supportsNonZeroFirstInstance = in_ext->supportsNonZeroFirstInstance;
+            VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT);
+            const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
+            out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
+            out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES:
         {
-            VkPhysicalDevicePCIBusInfoPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT);
-            const VkPhysicalDevicePCIBusInfoPropertiesEXT *in_ext = (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
-            out_ext->pciDomain = in_ext->pciDomain;
-            out_ext->pciBus = in_ext->pciBus;
-            out_ext->pciDevice = in_ext->pciDevice;
-            out_ext->pciFunction = in_ext->pciFunction;
+            VkPhysicalDeviceHostImageCopyProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES);
+            const VkPhysicalDeviceHostImageCopyProperties *in_ext = (const VkPhysicalDeviceHostImageCopyProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES;
+            out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount;
+            out_ext->pCopySrcLayouts = PtrToUlong(in_ext->pCopySrcLayouts);
+            out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount;
+            out_ext->pCopyDstLayouts = PtrToUlong(in_ext->pCopyDstLayouts);
+            memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t));
+            out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
         {
-            VkPhysicalDeviceDepthStencilResolveProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
-            const VkPhysicalDeviceDepthStencilResolveProperties *in_ext = (const VkPhysicalDeviceDepthStencilResolveProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
-            out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
-            out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
-            out_ext->independentResolveNone = in_ext->independentResolveNone;
-            out_ext->independentResolve = in_ext->independentResolve;
+            VkPhysicalDeviceIDProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
+            const VkPhysicalDeviceIDProperties *in_ext = (const VkPhysicalDeviceIDProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
+            memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
+            memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
+            memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
+            out_ext->deviceNodeMask = in_ext->deviceNodeMask;
+            out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
         {
-            VkPhysicalDeviceTransformFeedbackPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
-            const VkPhysicalDeviceTransformFeedbackPropertiesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
-            out_ext->maxTransformFeedbackStreams = in_ext->maxTransformFeedbackStreams;
-            out_ext->maxTransformFeedbackBuffers = in_ext->maxTransformFeedbackBuffers;
-            out_ext->maxTransformFeedbackBufferSize = in_ext->maxTransformFeedbackBufferSize;
-            out_ext->maxTransformFeedbackStreamDataSize = in_ext->maxTransformFeedbackStreamDataSize;
-            out_ext->maxTransformFeedbackBufferDataSize = in_ext->maxTransformFeedbackBufferDataSize;
-            out_ext->maxTransformFeedbackBufferDataStride = in_ext->maxTransformFeedbackBufferDataStride;
-            out_ext->transformFeedbackQueries = in_ext->transformFeedbackQueries;
-            out_ext->transformFeedbackStreamsLinesTriangles = in_ext->transformFeedbackStreamsLinesTriangles;
-            out_ext->transformFeedbackRasterizationStreamSelect = in_ext->transformFeedbackRasterizationStreamSelect;
-            out_ext->transformFeedbackDraw = in_ext->transformFeedbackDraw;
+            VkPhysicalDeviceImageAlignmentControlPropertiesMESA32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA);
+            const VkPhysicalDeviceImageAlignmentControlPropertiesMESA *in_ext = (const VkPhysicalDeviceImageAlignmentControlPropertiesMESA *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA;
+            out_ext->supportedImageAlignmentMask = in_ext->supportedImageAlignmentMask;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
         {
-            VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR);
-            const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR;
-            out_ext->meshAndTaskShaderDerivatives = in_ext->meshAndTaskShaderDerivatives;
+            VkPhysicalDeviceImageProcessing2PropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM);
+            const VkPhysicalDeviceImageProcessing2PropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing2PropertiesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM;
+            out_ext->maxBlockMatchWindow = in_ext->maxBlockMatchWindow;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
         {
-            VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV);
-            const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
-            out_ext->supportedQueues = in_ext->supportedQueues;
-            out_header = (void *)out_ext;
-            break;
+            VkPhysicalDeviceImageProcessingPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM);
+            const VkPhysicalDeviceImageProcessingPropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingPropertiesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
+            out_ext->maxWeightFilterPhases = in_ext->maxWeightFilterPhases;
+            out_ext->maxWeightFilterDimension = in_ext->maxWeightFilterDimension;
+            out_ext->maxBlockMatchRegion = in_ext->maxBlockMatchRegion;
+            out_ext->maxBoxFilterBlockSize = in_ext->maxBoxFilterBlockSize;
+            out_header = (void *)out_ext;
+            break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
         {
-            VkPhysicalDeviceMemoryDecompressionPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV);
-            const VkPhysicalDeviceMemoryDecompressionPropertiesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionPropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
-            out_ext->decompressionMethods = in_ext->decompressionMethods;
-            out_ext->maxDecompressionIndirectCount = in_ext->maxDecompressionIndirectCount;
+            VkPhysicalDeviceInlineUniformBlockProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES);
+            const VkPhysicalDeviceInlineUniformBlockProperties *in_ext = (const VkPhysicalDeviceInlineUniformBlockProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
+            out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
+            out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
+            out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+            out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
+            out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
         {
-            VkPhysicalDeviceShadingRateImagePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV);
-            const VkPhysicalDeviceShadingRateImagePropertiesNV *in_ext = (const VkPhysicalDeviceShadingRateImagePropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
-            out_ext->shadingRateTexelSize = in_ext->shadingRateTexelSize;
-            out_ext->shadingRatePaletteSize = in_ext->shadingRatePaletteSize;
-            out_ext->shadingRateMaxCoarseSamples = in_ext->shadingRateMaxCoarseSamples;
+            VkPhysicalDeviceLayeredDriverPropertiesMSFT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT);
+            const VkPhysicalDeviceLayeredDriverPropertiesMSFT *in_ext = (const VkPhysicalDeviceLayeredDriverPropertiesMSFT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT;
+            out_ext->underlyingAPI = in_ext->underlyingAPI;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceMeshShaderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV);
-            const VkPhysicalDeviceMeshShaderPropertiesNV *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
-            out_ext->maxDrawMeshTasksCount = in_ext->maxDrawMeshTasksCount;
-            out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
-            memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
-            out_ext->maxTaskTotalMemorySize = in_ext->maxTaskTotalMemorySize;
-            out_ext->maxTaskOutputCount = in_ext->maxTaskOutputCount;
-            out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
-            memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
-            out_ext->maxMeshTotalMemorySize = in_ext->maxMeshTotalMemorySize;
-            out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
-            out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
-            out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
-            out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
-            out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
+            VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT);
+            const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT;
+            out_ext->nativeUnalignedPerformance = in_ext->nativeUnalignedPerformance;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES:
+        {
+            VkPhysicalDeviceLineRasterizationProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES);
+            const VkPhysicalDeviceLineRasterizationProperties *in_ext = (const VkPhysicalDeviceLineRasterizationProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;
+            out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+        {
+            VkPhysicalDeviceMaintenance3Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
+            const VkPhysicalDeviceMaintenance3Properties *in_ext = (const VkPhysicalDeviceMaintenance3Properties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
+            out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
+            out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
+        {
+            VkPhysicalDeviceMaintenance4Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES);
+            const VkPhysicalDeviceMaintenance4Properties *in_ext = (const VkPhysicalDeviceMaintenance4Properties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
+            out_ext->maxBufferSize = in_ext->maxBufferSize;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
+        {
+            VkPhysicalDeviceMaintenance5Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES);
+            const VkPhysicalDeviceMaintenance5Properties *in_ext = (const VkPhysicalDeviceMaintenance5Properties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES;
+            out_ext->earlyFragmentMultisampleCoverageAfterSampleCounting = in_ext->earlyFragmentMultisampleCoverageAfterSampleCounting;
+            out_ext->earlyFragmentSampleMaskTestBeforeSampleCounting = in_ext->earlyFragmentSampleMaskTestBeforeSampleCounting;
+            out_ext->depthStencilSwizzleOneSupport = in_ext->depthStencilSwizzleOneSupport;
+            out_ext->polygonModePointSize = in_ext->polygonModePointSize;
+            out_ext->nonStrictSinglePixelWideLinesUseParallelogram = in_ext->nonStrictSinglePixelWideLinesUseParallelogram;
+            out_ext->nonStrictWideLinesUseParallelogram = in_ext->nonStrictWideLinesUseParallelogram;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES:
+        {
+            VkPhysicalDeviceMaintenance6Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES);
+            const VkPhysicalDeviceMaintenance6Properties *in_ext = (const VkPhysicalDeviceMaintenance6Properties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES;
+            out_ext->blockTexelViewCompatibleMultipleLayers = in_ext->blockTexelViewCompatibleMultipleLayers;
+            out_ext->maxCombinedImageSamplerDescriptorCount = in_ext->maxCombinedImageSamplerDescriptorCount;
+            out_ext->fragmentShadingRateClampCombinerInputs = in_ext->fragmentShadingRateClampCombinerInputs;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
+        {
+            VkPhysicalDeviceMaintenance9PropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR);
+            const VkPhysicalDeviceMaintenance9PropertiesKHR *in_ext = (const VkPhysicalDeviceMaintenance9PropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR;
+            out_ext->image2DViewOf3DSparse = in_ext->image2DViewOf3DSparse;
+            out_ext->defaultVertexAttributeValue = in_ext->defaultVertexAttributeValue;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
+        {
+            VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT);
+            const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT;
+            out_ext->minPlacedMemoryMapAlignment = in_ext->minPlacedMemoryMapAlignment;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
+        {
+            VkPhysicalDeviceMemoryDecompressionPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV);
+            const VkPhysicalDeviceMemoryDecompressionPropertiesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionPropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
+            out_ext->decompressionMethods = in_ext->decompressionMethods;
+            out_ext->maxDecompressionIndirectCount = in_ext->maxDecompressionIndirectCount;
             out_header = (void *)out_ext;
             break;
         }
@@ -35829,92 +35979,102 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
         {
-            VkPhysicalDeviceAccelerationStructurePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR);
-            const VkPhysicalDeviceAccelerationStructurePropertiesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructurePropertiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
-            out_ext->maxGeometryCount = in_ext->maxGeometryCount;
-            out_ext->maxInstanceCount = in_ext->maxInstanceCount;
-            out_ext->maxPrimitiveCount = in_ext->maxPrimitiveCount;
-            out_ext->maxPerStageDescriptorAccelerationStructures = in_ext->maxPerStageDescriptorAccelerationStructures;
-            out_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures = in_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
-            out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
-            out_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures = in_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures;
-            out_ext->minAccelerationStructureScratchOffsetAlignment = in_ext->minAccelerationStructureScratchOffsetAlignment;
+            VkPhysicalDeviceMeshShaderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV);
+            const VkPhysicalDeviceMeshShaderPropertiesNV *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
+            out_ext->maxDrawMeshTasksCount = in_ext->maxDrawMeshTasksCount;
+            out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
+            memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
+            out_ext->maxTaskTotalMemorySize = in_ext->maxTaskTotalMemorySize;
+            out_ext->maxTaskOutputCount = in_ext->maxTaskOutputCount;
+            out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
+            memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
+            out_ext->maxMeshTotalMemorySize = in_ext->maxMeshTotalMemorySize;
+            out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
+            out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
+            out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
+            out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
+            out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceRayTracingPipelinePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR);
-            const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
-            out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
-            out_ext->maxRayRecursionDepth = in_ext->maxRayRecursionDepth;
-            out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
-            out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
-            out_ext->shaderGroupHandleCaptureReplaySize = in_ext->shaderGroupHandleCaptureReplaySize;
-            out_ext->maxRayDispatchInvocationCount = in_ext->maxRayDispatchInvocationCount;
-            out_ext->shaderGroupHandleAlignment = in_ext->shaderGroupHandleAlignment;
-            out_ext->maxRayHitAttributeSize = in_ext->maxRayHitAttributeSize;
+            VkPhysicalDeviceMultiDrawPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT);
+            const VkPhysicalDeviceMultiDrawPropertiesEXT *in_ext = (const VkPhysicalDeviceMultiDrawPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
+            out_ext->maxMultiDrawCount = in_ext->maxMultiDrawCount;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
         {
-            VkPhysicalDeviceRayTracingPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV);
-            const VkPhysicalDeviceRayTracingPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingPropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
-            out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
-            out_ext->maxRecursionDepth = in_ext->maxRecursionDepth;
-            out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
-            out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
-            out_ext->maxGeometryCount = in_ext->maxGeometryCount;
-            out_ext->maxInstanceCount = in_ext->maxInstanceCount;
-            out_ext->maxTriangleCount = in_ext->maxTriangleCount;
-            out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
+            VkPhysicalDeviceMultiviewProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
+            const VkPhysicalDeviceMultiviewProperties *in_ext = (const VkPhysicalDeviceMultiviewProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
+            out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
+            out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceFragmentDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT);
-            const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
-            out_ext->minFragmentDensityTexelSize = in_ext->minFragmentDensityTexelSize;
-            out_ext->maxFragmentDensityTexelSize = in_ext->maxFragmentDensityTexelSize;
-            out_ext->fragmentDensityInvocations = in_ext->fragmentDensityInvocations;
+            VkPhysicalDeviceNestedCommandBufferPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT);
+            const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *in_ext = (const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT;
+            out_ext->maxCommandBufferNestingLevel = in_ext->maxCommandBufferNestingLevel;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT);
-            const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
-            out_ext->subsampledLoads = in_ext->subsampledLoads;
-            out_ext->subsampledCoarseReconstructionEarlyAccess = in_ext->subsampledCoarseReconstructionEarlyAccess;
-            out_ext->maxSubsampledArrayLayers = in_ext->maxSubsampledArrayLayers;
-            out_ext->maxDescriptorSetSubsampledSamplers = in_ext->maxDescriptorSetSubsampledSamplers;
+            VkPhysicalDeviceOpacityMicromapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT);
+            const VkPhysicalDeviceOpacityMicromapPropertiesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
+            out_ext->maxOpacity2StateSubdivisionLevel = in_ext->maxOpacity2StateSubdivisionLevel;
+            out_ext->maxOpacity4StateSubdivisionLevel = in_ext->maxOpacity4StateSubdivisionLevel;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
         {
-            VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT);
-            const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT;
-            out_ext->fragmentDensityOffsetGranularity = in_ext->fragmentDensityOffsetGranularity;
+            VkPhysicalDeviceOpticalFlowPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV);
+            const VkPhysicalDeviceOpticalFlowPropertiesNV *in_ext = (const VkPhysicalDeviceOpticalFlowPropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
+            out_ext->supportedOutputGridSizes = in_ext->supportedOutputGridSizes;
+            out_ext->supportedHintGridSizes = in_ext->supportedHintGridSizes;
+            out_ext->hintSupported = in_ext->hintSupported;
+            out_ext->costSupported = in_ext->costSupported;
+            out_ext->bidirectionalFlowSupported = in_ext->bidirectionalFlowSupported;
+            out_ext->globalFlowSupported = in_ext->globalFlowSupported;
+            out_ext->minWidth = in_ext->minWidth;
+            out_ext->minHeight = in_ext->minHeight;
+            out_ext->maxWidth = in_ext->maxWidth;
+            out_ext->maxHeight = in_ext->maxHeight;
+            out_ext->maxNumRegionsOfInterest = in_ext->maxNumRegionsOfInterest;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceCooperativeMatrixPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV);
-            const VkPhysicalDeviceCooperativeMatrixPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
-            out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages;
+            VkPhysicalDevicePCIBusInfoPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT);
+            const VkPhysicalDevicePCIBusInfoPropertiesEXT *in_ext = (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
+            out_ext->pciDomain = in_ext->pciDomain;
+            out_ext->pciBus = in_ext->pciBus;
+            out_ext->pciDevice = in_ext->pciDevice;
+            out_ext->pciFunction = in_ext->pciFunction;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
+        {
+            VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV);
+            const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV;
+            out_ext->maxPartitionCount = in_ext->maxPartitionCount;
             out_header = (void *)out_ext;
             break;
         }
@@ -35927,263 +36087,116 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV);
-            const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
-            out_ext->shaderSMCount = in_ext->shaderSMCount;
-            out_ext->shaderWarpsPerSM = in_ext->shaderWarpsPerSM;
+            VkPhysicalDevicePipelineBinaryPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR);
+            const VkPhysicalDevicePipelineBinaryPropertiesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryPropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR;
+            out_ext->pipelineBinaryInternalCache = in_ext->pipelineBinaryInternalCache;
+            out_ext->pipelineBinaryInternalCacheControl = in_ext->pipelineBinaryInternalCacheControl;
+            out_ext->pipelineBinaryPrefersInternalCache = in_ext->pipelineBinaryPrefersInternalCache;
+            out_ext->pipelineBinaryPrecompiledInternalCache = in_ext->pipelineBinaryPrecompiledInternalCache;
+            out_ext->pipelineBinaryCompressedData = in_ext->pipelineBinaryCompressedData;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES:
         {
-            VkPhysicalDeviceTexelBufferAlignmentProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES);
-            const VkPhysicalDeviceTexelBufferAlignmentProperties *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
-            out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
-            out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
-            out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
-            out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
+            VkPhysicalDevicePipelineRobustnessProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES);
+            const VkPhysicalDevicePipelineRobustnessProperties *in_ext = (const VkPhysicalDevicePipelineRobustnessProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES;
+            out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers;
+            out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers;
+            out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs;
+            out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
         {
-            VkPhysicalDeviceSubgroupSizeControlProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
-            const VkPhysicalDeviceSubgroupSizeControlProperties *in_ext = (const VkPhysicalDeviceSubgroupSizeControlProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
-            out_ext->minSubgroupSize = in_ext->minSubgroupSize;
-            out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
-            out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
-            out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
+            VkPhysicalDevicePointClippingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
+            const VkPhysicalDevicePointClippingProperties *in_ext = (const VkPhysicalDevicePointClippingProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
+            out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
         {
-            VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI);
-            const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
-            out_ext->maxSubpassShadingWorkgroupSizeAspectRatio = in_ext->maxSubpassShadingWorkgroupSizeAspectRatio;
+            VkPhysicalDeviceProtectedMemoryProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
+            const VkPhysicalDeviceProtectedMemoryProperties *in_ext = (const VkPhysicalDeviceProtectedMemoryProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
+            out_ext->protectedNoFault = in_ext->protectedNoFault;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI);
-            const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI;
-            memcpy(out_ext->maxWorkGroupCount, in_ext->maxWorkGroupCount, 3 * sizeof(uint32_t));
-            memcpy(out_ext->maxWorkGroupSize, in_ext->maxWorkGroupSize, 3 * sizeof(uint32_t));
-            out_ext->maxOutputClusterCount = in_ext->maxOutputClusterCount;
-            out_ext->indirectBufferOffsetAlignment = in_ext->indirectBufferOffsetAlignment;
+            VkPhysicalDeviceProvokingVertexPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
+            const VkPhysicalDeviceProvokingVertexPropertiesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
+            out_ext->provokingVertexModePerPipeline = in_ext->provokingVertexModePerPipeline;
+            out_ext->transformFeedbackPreservesTriangleFanProvokingVertex = in_ext->transformFeedbackPreservesTriangleFanProvokingVertex;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES:
         {
-            VkPhysicalDeviceLineRasterizationProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES);
-            const VkPhysicalDeviceLineRasterizationProperties *in_ext = (const VkPhysicalDeviceLineRasterizationProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;
-            out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits;
+            VkPhysicalDevicePushDescriptorProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES);
+            const VkPhysicalDevicePushDescriptorProperties *in_ext = (const VkPhysicalDevicePushDescriptorProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES;
+            out_ext->maxPushDescriptors = in_ext->maxPushDescriptors;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
         {
-            VkPhysicalDeviceVulkan11Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
-            const VkPhysicalDeviceVulkan11Properties *in_ext = (const VkPhysicalDeviceVulkan11Properties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
-            memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
-            memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
-            memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
-            out_ext->deviceNodeMask = in_ext->deviceNodeMask;
-            out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
-            out_ext->subgroupSize = in_ext->subgroupSize;
-            out_ext->subgroupSupportedStages = in_ext->subgroupSupportedStages;
-            out_ext->subgroupSupportedOperations = in_ext->subgroupSupportedOperations;
-            out_ext->subgroupQuadOperationsInAllStages = in_ext->subgroupQuadOperationsInAllStages;
-            out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
-            out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
-            out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
-            out_ext->protectedNoFault = in_ext->protectedNoFault;
-            out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
-            out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
+            VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV);
+            const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
+            out_ext->rayTracingInvocationReorderReorderingHint = in_ext->rayTracingInvocationReorderReorderingHint;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceVulkan12Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
-            const VkPhysicalDeviceVulkan12Properties *in_ext = (const VkPhysicalDeviceVulkan12Properties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
-            out_ext->driverID = in_ext->driverID;
-            memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
-            memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
-            out_ext->conformanceVersion = in_ext->conformanceVersion;
-            out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
-            out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
-            out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
-            out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
-            out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
-            out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
-            out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
-            out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
-            out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
-            out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
-            out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
-            out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
-            out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
-            out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
-            out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
-            out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
-            out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
-            out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
-            out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
-            out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
-            out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
-            out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
-            out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
-            out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
-            out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
-            out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
-            out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
-            out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
-            out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
-            out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
-            out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
-            out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
-            out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
-            out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
-            out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
-            out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
-            out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
-            out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
-            out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
-            out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
-            out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
-            out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
-            out_ext->independentResolveNone = in_ext->independentResolveNone;
-            out_ext->independentResolve = in_ext->independentResolve;
-            out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
-            out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
-            out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
-            out_ext->framebufferIntegerColorSampleCounts = in_ext->framebufferIntegerColorSampleCounts;
+            VkPhysicalDeviceRayTracingPipelinePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR);
+            const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
+            out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
+            out_ext->maxRayRecursionDepth = in_ext->maxRayRecursionDepth;
+            out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
+            out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
+            out_ext->shaderGroupHandleCaptureReplaySize = in_ext->shaderGroupHandleCaptureReplaySize;
+            out_ext->maxRayDispatchInvocationCount = in_ext->maxRayDispatchInvocationCount;
+            out_ext->shaderGroupHandleAlignment = in_ext->shaderGroupHandleAlignment;
+            out_ext->maxRayHitAttributeSize = in_ext->maxRayHitAttributeSize;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
         {
-            VkPhysicalDeviceVulkan13Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES);
-            const VkPhysicalDeviceVulkan13Properties *in_ext = (const VkPhysicalDeviceVulkan13Properties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
-            out_ext->minSubgroupSize = in_ext->minSubgroupSize;
-            out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
-            out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
-            out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
-            out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
-            out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
-            out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
-            out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
-            out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
-            out_ext->maxInlineUniformTotalSize = in_ext->maxInlineUniformTotalSize;
-            out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
-            out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
-            out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
-            out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
-            out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
-            out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
-            out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
-            out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
-            out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
-            out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
-            out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
-            out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
-            out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
-            out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
-            out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
-            out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
-            out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
-            out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
-            out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
-            out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
-            out_ext->maxBufferSize = in_ext->maxBufferSize;
+            VkPhysicalDeviceRayTracingPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV);
+            const VkPhysicalDeviceRayTracingPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingPropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
+            out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
+            out_ext->maxRecursionDepth = in_ext->maxRecursionDepth;
+            out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
+            out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
+            out_ext->maxGeometryCount = in_ext->maxGeometryCount;
+            out_ext->maxInstanceCount = in_ext->maxInstanceCount;
+            out_ext->maxTriangleCount = in_ext->maxTriangleCount;
+            out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
         {
-            VkPhysicalDeviceVulkan14Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES);
-            const VkPhysicalDeviceVulkan14Properties *in_ext = (const VkPhysicalDeviceVulkan14Properties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES;
-            out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits;
-            out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor;
-            out_ext->supportsNonZeroFirstInstance = in_ext->supportsNonZeroFirstInstance;
-            out_ext->maxPushDescriptors = in_ext->maxPushDescriptors;
-            out_ext->dynamicRenderingLocalReadDepthStencilAttachments = in_ext->dynamicRenderingLocalReadDepthStencilAttachments;
-            out_ext->dynamicRenderingLocalReadMultisampledAttachments = in_ext->dynamicRenderingLocalReadMultisampledAttachments;
-            out_ext->earlyFragmentMultisampleCoverageAfterSampleCounting = in_ext->earlyFragmentMultisampleCoverageAfterSampleCounting;
-            out_ext->earlyFragmentSampleMaskTestBeforeSampleCounting = in_ext->earlyFragmentSampleMaskTestBeforeSampleCounting;
-            out_ext->depthStencilSwizzleOneSupport = in_ext->depthStencilSwizzleOneSupport;
-            out_ext->polygonModePointSize = in_ext->polygonModePointSize;
-            out_ext->nonStrictSinglePixelWideLinesUseParallelogram = in_ext->nonStrictSinglePixelWideLinesUseParallelogram;
-            out_ext->nonStrictWideLinesUseParallelogram = in_ext->nonStrictWideLinesUseParallelogram;
-            out_ext->blockTexelViewCompatibleMultipleLayers = in_ext->blockTexelViewCompatibleMultipleLayers;
-            out_ext->maxCombinedImageSamplerDescriptorCount = in_ext->maxCombinedImageSamplerDescriptorCount;
-            out_ext->fragmentShadingRateClampCombinerInputs = in_ext->fragmentShadingRateClampCombinerInputs;
-            out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers;
-            out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers;
-            out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs;
-            out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages;
-            out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount;
-            out_ext->pCopySrcLayouts = PtrToUlong(in_ext->pCopySrcLayouts);
-            out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount;
-            out_ext->pCopyDstLayouts = PtrToUlong(in_ext->pCopyDstLayouts);
-            memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t));
-            out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
-        {
-            VkPhysicalDeviceCustomBorderColorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT);
-            const VkPhysicalDeviceCustomBorderColorPropertiesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
-            out_ext->maxCustomBorderColorSamplers = in_ext->maxCustomBorderColorSamplers;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
-        {
-            VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT);
-            const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
-            out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
-        {
-            VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV);
-            const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV;
-            out_ext->maxPartitionCount = in_ext->maxPartitionCount;
+            VkPhysicalDeviceRenderPassStripedPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM);
+            const VkPhysicalDeviceRenderPassStripedPropertiesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedPropertiesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM;
+            out_ext->renderPassStripeGranularity = in_ext->renderPassStripeGranularity;
+            out_ext->maxRenderPassStripes = in_ext->maxRenderPassStripes;
             out_header = (void *)out_ext;
             break;
         }
@@ -36197,140 +36210,89 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
-        {
-            VkPhysicalDeviceFragmentShadingRatePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR);
-            const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
-            out_ext->minFragmentShadingRateAttachmentTexelSize = in_ext->minFragmentShadingRateAttachmentTexelSize;
-            out_ext->maxFragmentShadingRateAttachmentTexelSize = in_ext->maxFragmentShadingRateAttachmentTexelSize;
-            out_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
-            out_ext->primitiveFragmentShadingRateWithMultipleViewports = in_ext->primitiveFragmentShadingRateWithMultipleViewports;
-            out_ext->layeredShadingRateAttachments = in_ext->layeredShadingRateAttachments;
-            out_ext->fragmentShadingRateNonTrivialCombinerOps = in_ext->fragmentShadingRateNonTrivialCombinerOps;
-            out_ext->maxFragmentSize = in_ext->maxFragmentSize;
-            out_ext->maxFragmentSizeAspectRatio = in_ext->maxFragmentSizeAspectRatio;
-            out_ext->maxFragmentShadingRateCoverageSamples = in_ext->maxFragmentShadingRateCoverageSamples;
-            out_ext->maxFragmentShadingRateRasterizationSamples = in_ext->maxFragmentShadingRateRasterizationSamples;
-            out_ext->fragmentShadingRateWithShaderDepthStencilWrites = in_ext->fragmentShadingRateWithShaderDepthStencilWrites;
-            out_ext->fragmentShadingRateWithSampleMask = in_ext->fragmentShadingRateWithSampleMask;
-            out_ext->fragmentShadingRateWithShaderSampleMask = in_ext->fragmentShadingRateWithShaderSampleMask;
-            out_ext->fragmentShadingRateWithConservativeRasterization = in_ext->fragmentShadingRateWithConservativeRasterization;
-            out_ext->fragmentShadingRateWithFragmentShaderInterlock = in_ext->fragmentShadingRateWithFragmentShaderInterlock;
-            out_ext->fragmentShadingRateWithCustomSampleLocations = in_ext->fragmentShadingRateWithCustomSampleLocations;
-            out_ext->fragmentShadingRateStrictMultiplyCombiner = in_ext->fragmentShadingRateStrictMultiplyCombiner;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV);
-            const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
-            out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
+            VkPhysicalDeviceSampleLocationsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT);
+            const VkPhysicalDeviceSampleLocationsPropertiesEXT *in_ext = (const VkPhysicalDeviceSampleLocationsPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
+            out_ext->sampleLocationSampleCounts = in_ext->sampleLocationSampleCounts;
+            out_ext->maxSampleLocationGridSize = in_ext->maxSampleLocationGridSize;
+            memcpy(out_ext->sampleLocationCoordinateRange, in_ext->sampleLocationCoordinateRange, 2 * sizeof(float));
+            out_ext->sampleLocationSubPixelBits = in_ext->sampleLocationSubPixelBits;
+            out_ext->variableSampleLocations = in_ext->variableSampleLocations;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
         {
-            VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT);
-            const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT;
-            out_ext->nativeUnalignedPerformance = in_ext->nativeUnalignedPerformance;
+            VkPhysicalDeviceSamplerFilterMinmaxProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
+            const VkPhysicalDeviceSamplerFilterMinmaxProperties *in_ext = (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
+            out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
+            out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
         {
-            VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT);
-            const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT;
-            out_ext->maxIndirectPipelineCount = in_ext->maxIndirectPipelineCount;
-            out_ext->maxIndirectShaderObjectCount = in_ext->maxIndirectShaderObjectCount;
-            out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount;
-            out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount;
-            out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset;
-            out_ext->maxIndirectCommandsIndirectStride = in_ext->maxIndirectCommandsIndirectStride;
-            out_ext->supportedIndirectCommandsInputModes = in_ext->supportedIndirectCommandsInputModes;
-            out_ext->supportedIndirectCommandsShaderStages = in_ext->supportedIndirectCommandsShaderStages;
-            out_ext->supportedIndirectCommandsShaderStagesPipelineBinding = in_ext->supportedIndirectCommandsShaderStagesPipelineBinding;
-            out_ext->supportedIndirectCommandsShaderStagesShaderBinding = in_ext->supportedIndirectCommandsShaderStagesShaderBinding;
-            out_ext->deviceGeneratedCommandsTransformFeedback = in_ext->deviceGeneratedCommandsTransformFeedback;
-            out_ext->deviceGeneratedCommandsMultiDrawIndirectCount = in_ext->deviceGeneratedCommandsMultiDrawIndirectCount;
+            VkPhysicalDeviceSchedulingControlsPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM);
+            const VkPhysicalDeviceSchedulingControlsPropertiesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsPropertiesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM;
+            out_ext->schedulingControlsFlags = in_ext->schedulingControlsFlags;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
         {
-            VkPhysicalDeviceHostImageCopyProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES);
-            const VkPhysicalDeviceHostImageCopyProperties *in_ext = (const VkPhysicalDeviceHostImageCopyProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES;
-            out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount;
-            out_ext->pCopySrcLayouts = PtrToUlong(in_ext->pCopySrcLayouts);
-            out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount;
-            out_ext->pCopyDstLayouts = PtrToUlong(in_ext->pCopyDstLayouts);
-            memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t));
-            out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements;
+            VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM);
+            const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
+            out_ext->shaderCoreMask = in_ext->shaderCoreMask;
+            out_ext->shaderCoreCount = in_ext->shaderCoreCount;
+            out_ext->shaderWarpsPerCore = in_ext->shaderWarpsPerCore;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
         {
-            VkPhysicalDeviceProvokingVertexPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
-            const VkPhysicalDeviceProvokingVertexPropertiesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
-            out_ext->provokingVertexModePerPipeline = in_ext->provokingVertexModePerPipeline;
-            out_ext->transformFeedbackPreservesTriangleFanProvokingVertex = in_ext->transformFeedbackPreservesTriangleFanProvokingVertex;
+            VkPhysicalDeviceShaderCoreProperties2AMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD);
+            const VkPhysicalDeviceShaderCoreProperties2AMD *in_ext = (const VkPhysicalDeviceShaderCoreProperties2AMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
+            out_ext->shaderCoreFeatures = in_ext->shaderCoreFeatures;
+            out_ext->activeComputeUnitCount = in_ext->activeComputeUnitCount;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
         {
-            VkPhysicalDeviceDescriptorBufferPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT);
-            const VkPhysicalDeviceDescriptorBufferPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
-            out_ext->combinedImageSamplerDescriptorSingleArray = in_ext->combinedImageSamplerDescriptorSingleArray;
-            out_ext->bufferlessPushDescriptors = in_ext->bufferlessPushDescriptors;
-            out_ext->allowSamplerImageViewPostSubmitCreation = in_ext->allowSamplerImageViewPostSubmitCreation;
-            out_ext->descriptorBufferOffsetAlignment = in_ext->descriptorBufferOffsetAlignment;
-            out_ext->maxDescriptorBufferBindings = in_ext->maxDescriptorBufferBindings;
-            out_ext->maxResourceDescriptorBufferBindings = in_ext->maxResourceDescriptorBufferBindings;
-            out_ext->maxSamplerDescriptorBufferBindings = in_ext->maxSamplerDescriptorBufferBindings;
-            out_ext->maxEmbeddedImmutableSamplerBindings = in_ext->maxEmbeddedImmutableSamplerBindings;
-            out_ext->maxEmbeddedImmutableSamplers = in_ext->maxEmbeddedImmutableSamplers;
-            out_ext->bufferCaptureReplayDescriptorDataSize = in_ext->bufferCaptureReplayDescriptorDataSize;
-            out_ext->imageCaptureReplayDescriptorDataSize = in_ext->imageCaptureReplayDescriptorDataSize;
-            out_ext->imageViewCaptureReplayDescriptorDataSize = in_ext->imageViewCaptureReplayDescriptorDataSize;
-            out_ext->samplerCaptureReplayDescriptorDataSize = in_ext->samplerCaptureReplayDescriptorDataSize;
-            out_ext->accelerationStructureCaptureReplayDescriptorDataSize = in_ext->accelerationStructureCaptureReplayDescriptorDataSize;
-            out_ext->samplerDescriptorSize = in_ext->samplerDescriptorSize;
-            out_ext->combinedImageSamplerDescriptorSize = in_ext->combinedImageSamplerDescriptorSize;
-            out_ext->sampledImageDescriptorSize = in_ext->sampledImageDescriptorSize;
-            out_ext->storageImageDescriptorSize = in_ext->storageImageDescriptorSize;
-            out_ext->uniformTexelBufferDescriptorSize = in_ext->uniformTexelBufferDescriptorSize;
-            out_ext->robustUniformTexelBufferDescriptorSize = in_ext->robustUniformTexelBufferDescriptorSize;
-            out_ext->storageTexelBufferDescriptorSize = in_ext->storageTexelBufferDescriptorSize;
-            out_ext->robustStorageTexelBufferDescriptorSize = in_ext->robustStorageTexelBufferDescriptorSize;
-            out_ext->uniformBufferDescriptorSize = in_ext->uniformBufferDescriptorSize;
-            out_ext->robustUniformBufferDescriptorSize = in_ext->robustUniformBufferDescriptorSize;
-            out_ext->storageBufferDescriptorSize = in_ext->storageBufferDescriptorSize;
-            out_ext->robustStorageBufferDescriptorSize = in_ext->robustStorageBufferDescriptorSize;
-            out_ext->inputAttachmentDescriptorSize = in_ext->inputAttachmentDescriptorSize;
-            out_ext->accelerationStructureDescriptorSize = in_ext->accelerationStructureDescriptorSize;
-            out_ext->maxSamplerDescriptorBufferRange = in_ext->maxSamplerDescriptorBufferRange;
-            out_ext->maxResourceDescriptorBufferRange = in_ext->maxResourceDescriptorBufferRange;
-            out_ext->samplerDescriptorBufferAddressSpaceSize = in_ext->samplerDescriptorBufferAddressSpaceSize;
-            out_ext->resourceDescriptorBufferAddressSpaceSize = in_ext->resourceDescriptorBufferAddressSpaceSize;
-            out_ext->descriptorBufferAddressSpaceSize = in_ext->descriptorBufferAddressSpaceSize;
+            VkPhysicalDeviceShaderCorePropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD);
+            const VkPhysicalDeviceShaderCorePropertiesAMD *in_ext = (const VkPhysicalDeviceShaderCorePropertiesAMD *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
+            out_ext->shaderEngineCount = in_ext->shaderEngineCount;
+            out_ext->shaderArraysPerEngineCount = in_ext->shaderArraysPerEngineCount;
+            out_ext->computeUnitsPerShaderArray = in_ext->computeUnitsPerShaderArray;
+            out_ext->simdPerComputeUnit = in_ext->simdPerComputeUnit;
+            out_ext->wavefrontsPerSimd = in_ext->wavefrontsPerSimd;
+            out_ext->wavefrontSize = in_ext->wavefrontSize;
+            out_ext->sgprsPerSimd = in_ext->sgprsPerSimd;
+            out_ext->minSgprAllocation = in_ext->minSgprAllocation;
+            out_ext->maxSgprAllocation = in_ext->maxSgprAllocation;
+            out_ext->sgprAllocationGranularity = in_ext->sgprAllocationGranularity;
+            out_ext->vgprsPerSimd = in_ext->vgprsPerSimd;
+            out_ext->minVgprAllocation = in_ext->minVgprAllocation;
+            out_ext->maxVgprAllocation = in_ext->maxVgprAllocation;
+            out_ext->vgprAllocationGranularity = in_ext->vgprAllocationGranularity;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
         {
-            VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT);
-            const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
-            out_ext->combinedImageSamplerDensityMapDescriptorSize = in_ext->combinedImageSamplerDensityMapDescriptorSize;
+            VkPhysicalDeviceShaderCorePropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM);
+            const VkPhysicalDeviceShaderCorePropertiesARM *in_ext = (const VkPhysicalDeviceShaderCorePropertiesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM;
+            out_ext->pixelRate = in_ext->pixelRate;
+            out_ext->texelRate = in_ext->texelRate;
+            out_ext->fmaRate = in_ext->fmaRate;
             out_header = (void *)out_ext;
             break;
         }
@@ -36372,178 +36334,120 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR);
-            const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
-            out_ext->triStripVertexOrderIndependentOfProvokingVertex = in_ext->triStripVertexOrderIndependentOfProvokingVertex;
+            VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT);
+            const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
+            memcpy(out_ext->shaderModuleIdentifierAlgorithmUUID, in_ext->shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE * sizeof(uint8_t));
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
         {
-            VkPhysicalDevicePipelineBinaryPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR);
-            const VkPhysicalDevicePipelineBinaryPropertiesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryPropertiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR;
-            out_ext->pipelineBinaryInternalCache = in_ext->pipelineBinaryInternalCache;
-            out_ext->pipelineBinaryInternalCacheControl = in_ext->pipelineBinaryInternalCacheControl;
-            out_ext->pipelineBinaryPrefersInternalCache = in_ext->pipelineBinaryPrefersInternalCache;
-            out_ext->pipelineBinaryPrecompiledInternalCache = in_ext->pipelineBinaryPrecompiledInternalCache;
-            out_ext->pipelineBinaryCompressedData = in_ext->pipelineBinaryCompressedData;
+            VkPhysicalDeviceShaderObjectPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT);
+            const VkPhysicalDeviceShaderObjectPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderObjectPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
+            memcpy(out_ext->shaderBinaryUUID, in_ext->shaderBinaryUUID, VK_UUID_SIZE * sizeof(uint8_t));
+            out_ext->shaderBinaryVersion = in_ext->shaderBinaryVersion;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
         {
-            VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT);
-            const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
-            out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
-            out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
-        {
-            VkPhysicalDeviceNestedCommandBufferPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT);
-            const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *in_ext = (const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT;
-            out_ext->maxCommandBufferNestingLevel = in_ext->maxCommandBufferNestingLevel;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
-        {
-            VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT);
-            const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
-            memcpy(out_ext->shaderModuleIdentifierAlgorithmUUID, in_ext->shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE * sizeof(uint8_t));
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
-        {
-            VkPhysicalDeviceOpacityMicromapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT);
-            const VkPhysicalDeviceOpacityMicromapPropertiesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
-            out_ext->maxOpacity2StateSubdivisionLevel = in_ext->maxOpacity2StateSubdivisionLevel;
-            out_ext->maxOpacity4StateSubdivisionLevel = in_ext->maxOpacity4StateSubdivisionLevel;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES:
-        {
-            VkPhysicalDevicePipelineRobustnessProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES);
-            const VkPhysicalDevicePipelineRobustnessProperties *in_ext = (const VkPhysicalDevicePipelineRobustnessProperties *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES;
-            out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers;
-            out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers;
-            out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs;
-            out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
-        {
-            VkPhysicalDeviceImageProcessingPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM);
-            const VkPhysicalDeviceImageProcessingPropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingPropertiesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
-            out_ext->maxWeightFilterPhases = in_ext->maxWeightFilterPhases;
-            out_ext->maxWeightFilterDimension = in_ext->maxWeightFilterDimension;
-            out_ext->maxBlockMatchRegion = in_ext->maxBlockMatchRegion;
-            out_ext->maxBoxFilterBlockSize = in_ext->maxBoxFilterBlockSize;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
-        {
-            VkPhysicalDeviceOpticalFlowPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV);
-            const VkPhysicalDeviceOpticalFlowPropertiesNV *in_ext = (const VkPhysicalDeviceOpticalFlowPropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
-            out_ext->supportedOutputGridSizes = in_ext->supportedOutputGridSizes;
-            out_ext->supportedHintGridSizes = in_ext->supportedHintGridSizes;
-            out_ext->hintSupported = in_ext->hintSupported;
-            out_ext->costSupported = in_ext->costSupported;
-            out_ext->bidirectionalFlowSupported = in_ext->bidirectionalFlowSupported;
-            out_ext->globalFlowSupported = in_ext->globalFlowSupported;
-            out_ext->minWidth = in_ext->minWidth;
-            out_ext->minHeight = in_ext->minHeight;
-            out_ext->maxWidth = in_ext->maxWidth;
-            out_ext->maxHeight = in_ext->maxHeight;
-            out_ext->maxNumRegionsOfInterest = in_ext->maxNumRegionsOfInterest;
+            VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV);
+            const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
+            out_ext->shaderSMCount = in_ext->shaderSMCount;
+            out_ext->shaderWarpsPerSM = in_ext->shaderWarpsPerSM;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM);
-            const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
-            out_ext->shaderCoreMask = in_ext->shaderCoreMask;
-            out_ext->shaderCoreCount = in_ext->shaderCoreCount;
-            out_ext->shaderWarpsPerCore = in_ext->shaderWarpsPerCore;
+            VkPhysicalDeviceShaderTileImagePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT);
+            const VkPhysicalDeviceShaderTileImagePropertiesEXT *in_ext = (const VkPhysicalDeviceShaderTileImagePropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
+            out_ext->shaderTileImageCoherentReadAccelerated = in_ext->shaderTileImageCoherentReadAccelerated;
+            out_ext->shaderTileImageReadSampleFromPixelRateInvocation = in_ext->shaderTileImageReadSampleFromPixelRateInvocation;
+            out_ext->shaderTileImageReadFromHelperInvocation = in_ext->shaderTileImageReadFromHelperInvocation;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
         {
-            VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV);
-            const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
-            out_ext->rayTracingInvocationReorderReorderingHint = in_ext->rayTracingInvocationReorderReorderingHint;
+            VkPhysicalDeviceShadingRateImagePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV);
+            const VkPhysicalDeviceShadingRateImagePropertiesNV *in_ext = (const VkPhysicalDeviceShadingRateImagePropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
+            out_ext->shadingRateTexelSize = in_ext->shadingRateTexelSize;
+            out_ext->shadingRatePaletteSize = in_ext->shadingRatePaletteSize;
+            out_ext->shadingRateMaxCoarseSamples = in_ext->shadingRateMaxCoarseSamples;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
         {
-            VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV);
-            const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV;
-            out_ext->extendedSparseAddressSpaceSize = in_ext->extendedSparseAddressSpaceSize;
-            out_ext->extendedSparseImageUsageFlags = in_ext->extendedSparseImageUsageFlags;
-            out_ext->extendedSparseBufferUsageFlags = in_ext->extendedSparseBufferUsageFlags;
+            VkPhysicalDeviceSubgroupProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
+            const VkPhysicalDeviceSubgroupProperties *in_ext = (const VkPhysicalDeviceSubgroupProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
+            out_ext->subgroupSize = in_ext->subgroupSize;
+            out_ext->supportedStages = in_ext->supportedStages;
+            out_ext->supportedOperations = in_ext->supportedOperations;
+            out_ext->quadOperationsInAllStages = in_ext->quadOperationsInAllStages;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
         {
-            VkPhysicalDeviceShaderCorePropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM);
-            const VkPhysicalDeviceShaderCorePropertiesARM *in_ext = (const VkPhysicalDeviceShaderCorePropertiesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM;
-            out_ext->pixelRate = in_ext->pixelRate;
-            out_ext->texelRate = in_ext->texelRate;
-            out_ext->fmaRate = in_ext->fmaRate;
+            VkPhysicalDeviceSubgroupSizeControlProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
+            const VkPhysicalDeviceSubgroupSizeControlProperties *in_ext = (const VkPhysicalDeviceSubgroupSizeControlProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
+            out_ext->minSubgroupSize = in_ext->minSubgroupSize;
+            out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
+            out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
+            out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
         {
-            VkPhysicalDeviceShaderObjectPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT);
-            const VkPhysicalDeviceShaderObjectPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderObjectPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
-            memcpy(out_ext->shaderBinaryUUID, in_ext->shaderBinaryUUID, VK_UUID_SIZE * sizeof(uint8_t));
-            out_ext->shaderBinaryVersion = in_ext->shaderBinaryVersion;
+            VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI);
+            const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
+            out_ext->maxSubpassShadingWorkgroupSizeAspectRatio = in_ext->maxSubpassShadingWorkgroupSizeAspectRatio;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
         {
-            VkPhysicalDeviceShaderTileImagePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT);
-            const VkPhysicalDeviceShaderTileImagePropertiesEXT *in_ext = (const VkPhysicalDeviceShaderTileImagePropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
-            out_ext->shaderTileImageCoherentReadAccelerated = in_ext->shaderTileImageCoherentReadAccelerated;
-            out_ext->shaderTileImageReadSampleFromPixelRateInvocation = in_ext->shaderTileImageReadSampleFromPixelRateInvocation;
-            out_ext->shaderTileImageReadFromHelperInvocation = in_ext->shaderTileImageReadFromHelperInvocation;
+            VkPhysicalDeviceTensorPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM);
+            const VkPhysicalDeviceTensorPropertiesARM *in_ext = (const VkPhysicalDeviceTensorPropertiesARM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM;
+            out_ext->maxTensorDimensionCount = in_ext->maxTensorDimensionCount;
+            out_ext->maxTensorElements = in_ext->maxTensorElements;
+            out_ext->maxPerDimensionTensorElements = in_ext->maxPerDimensionTensorElements;
+            out_ext->maxTensorStride = in_ext->maxTensorStride;
+            out_ext->maxTensorSize = in_ext->maxTensorSize;
+            out_ext->maxTensorShaderAccessArrayLength = in_ext->maxTensorShaderAccessArrayLength;
+            out_ext->maxTensorShaderAccessSize = in_ext->maxTensorShaderAccessSize;
+            out_ext->maxDescriptorSetStorageTensors = in_ext->maxDescriptorSetStorageTensors;
+            out_ext->maxPerStageDescriptorSetStorageTensors = in_ext->maxPerStageDescriptorSetStorageTensors;
+            out_ext->maxDescriptorSetUpdateAfterBindStorageTensors = in_ext->maxDescriptorSetUpdateAfterBindStorageTensors;
+            out_ext->maxPerStageDescriptorUpdateAfterBindStorageTensors = in_ext->maxPerStageDescriptorUpdateAfterBindStorageTensors;
+            out_ext->shaderStorageTensorArrayNonUniformIndexingNative = in_ext->shaderStorageTensorArrayNonUniformIndexingNative;
+            out_ext->shaderTensorSupportedStages = in_ext->shaderTensorSupportedStages;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
         {
-            VkPhysicalDeviceCooperativeMatrixPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR);
-            const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR;
-            out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages;
+            VkPhysicalDeviceTexelBufferAlignmentProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES);
+            const VkPhysicalDeviceTexelBufferAlignmentProperties *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
+            out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
+            out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
+            out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
+            out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
             out_header = (void *)out_ext;
             break;
         }
@@ -36557,134 +36461,230 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
-        {
-            VkPhysicalDeviceImageProcessing2PropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM);
-            const VkPhysicalDeviceImageProcessing2PropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing2PropertiesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM;
-            out_ext->maxBlockMatchWindow = in_ext->maxBlockMatchWindow;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
-        {
-            VkPhysicalDeviceLayeredDriverPropertiesMSFT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT);
-            const VkPhysicalDeviceLayeredDriverPropertiesMSFT *in_ext = (const VkPhysicalDeviceLayeredDriverPropertiesMSFT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT;
-            out_ext->underlyingAPI = in_ext->underlyingAPI;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
-        {
-            VkPhysicalDeviceSchedulingControlsPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM);
-            const VkPhysicalDeviceSchedulingControlsPropertiesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsPropertiesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM;
-            out_ext->schedulingControlsFlags = in_ext->schedulingControlsFlags;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
         {
-            VkPhysicalDeviceRenderPassStripedPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM);
-            const VkPhysicalDeviceRenderPassStripedPropertiesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedPropertiesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM;
-            out_ext->renderPassStripeGranularity = in_ext->renderPassStripeGranularity;
-            out_ext->maxRenderPassStripes = in_ext->maxRenderPassStripes;
+            VkPhysicalDeviceTileShadingPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM);
+            const VkPhysicalDeviceTileShadingPropertiesQCOM *in_ext = (const VkPhysicalDeviceTileShadingPropertiesQCOM *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM;
+            out_ext->maxApronSize = in_ext->maxApronSize;
+            out_ext->preferNonCoherent = in_ext->preferNonCoherent;
+            out_ext->tileGranularity = in_ext->tileGranularity;
+            out_ext->maxTileShadingRate = in_ext->maxTileShadingRate;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
         {
-            VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT);
-            const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT;
-            out_ext->minPlacedMemoryMapAlignment = in_ext->minPlacedMemoryMapAlignment;
+            VkPhysicalDeviceTimelineSemaphoreProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
+            const VkPhysicalDeviceTimelineSemaphoreProperties *in_ext = (const VkPhysicalDeviceTimelineSemaphoreProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
+            out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceImageAlignmentControlPropertiesMESA32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA);
-            const VkPhysicalDeviceImageAlignmentControlPropertiesMESA *in_ext = (const VkPhysicalDeviceImageAlignmentControlPropertiesMESA *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA;
-            out_ext->supportedImageAlignmentMask = in_ext->supportedImageAlignmentMask;
+            VkPhysicalDeviceTransformFeedbackPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
+            const VkPhysicalDeviceTransformFeedbackPropertiesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
+            out_ext->maxTransformFeedbackStreams = in_ext->maxTransformFeedbackStreams;
+            out_ext->maxTransformFeedbackBuffers = in_ext->maxTransformFeedbackBuffers;
+            out_ext->maxTransformFeedbackBufferSize = in_ext->maxTransformFeedbackBufferSize;
+            out_ext->maxTransformFeedbackStreamDataSize = in_ext->maxTransformFeedbackStreamDataSize;
+            out_ext->maxTransformFeedbackBufferDataSize = in_ext->maxTransformFeedbackBufferDataSize;
+            out_ext->maxTransformFeedbackBufferDataStride = in_ext->maxTransformFeedbackBufferDataStride;
+            out_ext->transformFeedbackQueries = in_ext->transformFeedbackQueries;
+            out_ext->transformFeedbackStreamsLinesTriangles = in_ext->transformFeedbackStreamsLinesTriangles;
+            out_ext->transformFeedbackRasterizationStreamSelect = in_ext->transformFeedbackRasterizationStreamSelect;
+            out_ext->transformFeedbackDraw = in_ext->transformFeedbackDraw;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES:
         {
-            VkPhysicalDeviceCooperativeMatrix2PropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV);
-            const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV;
-            out_ext->cooperativeMatrixWorkgroupScopeMaxWorkgroupSize = in_ext->cooperativeMatrixWorkgroupScopeMaxWorkgroupSize;
-            out_ext->cooperativeMatrixFlexibleDimensionsMaxDimension = in_ext->cooperativeMatrixFlexibleDimensionsMaxDimension;
-            out_ext->cooperativeMatrixWorkgroupScopeReservedSharedMemory = in_ext->cooperativeMatrixWorkgroupScopeReservedSharedMemory;
+            VkPhysicalDeviceVertexAttributeDivisorProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES);
+            const VkPhysicalDeviceVertexAttributeDivisorProperties *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorProperties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES;
+            out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor;
+            out_ext->supportsNonZeroFirstInstance = in_ext->supportsNonZeroFirstInstance;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
         {
-            VkPhysicalDeviceCooperativeVectorPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV);
-            const VkPhysicalDeviceCooperativeVectorPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeVectorPropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV;
-            out_ext->cooperativeVectorSupportedStages = in_ext->cooperativeVectorSupportedStages;
-            out_ext->cooperativeVectorTrainingFloat16Accumulation = in_ext->cooperativeVectorTrainingFloat16Accumulation;
-            out_ext->cooperativeVectorTrainingFloat32Accumulation = in_ext->cooperativeVectorTrainingFloat32Accumulation;
-            out_ext->maxCooperativeVectorComponents = in_ext->maxCooperativeVectorComponents;
+            VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT);
+            const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
+            out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
         {
-            VkPhysicalDeviceTileShadingPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM);
-            const VkPhysicalDeviceTileShadingPropertiesQCOM *in_ext = (const VkPhysicalDeviceTileShadingPropertiesQCOM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM;
-            out_ext->maxApronSize = in_ext->maxApronSize;
-            out_ext->preferNonCoherent = in_ext->preferNonCoherent;
-            out_ext->tileGranularity = in_ext->tileGranularity;
-            out_ext->maxTileShadingRate = in_ext->maxTileShadingRate;
+            VkPhysicalDeviceVulkan11Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
+            const VkPhysicalDeviceVulkan11Properties *in_ext = (const VkPhysicalDeviceVulkan11Properties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
+            memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
+            memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
+            memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
+            out_ext->deviceNodeMask = in_ext->deviceNodeMask;
+            out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
+            out_ext->subgroupSize = in_ext->subgroupSize;
+            out_ext->subgroupSupportedStages = in_ext->subgroupSupportedStages;
+            out_ext->subgroupSupportedOperations = in_ext->subgroupSupportedOperations;
+            out_ext->subgroupQuadOperationsInAllStages = in_ext->subgroupQuadOperationsInAllStages;
+            out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
+            out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
+            out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
+            out_ext->protectedNoFault = in_ext->protectedNoFault;
+            out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
+            out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
         {
-            VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE);
-            const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *in_ext = (const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE;
-            out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers;
+            VkPhysicalDeviceVulkan12Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
+            const VkPhysicalDeviceVulkan12Properties *in_ext = (const VkPhysicalDeviceVulkan12Properties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
+            out_ext->driverID = in_ext->driverID;
+            memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
+            memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
+            out_ext->conformanceVersion = in_ext->conformanceVersion;
+            out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
+            out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
+            out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
+            out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
+            out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
+            out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
+            out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
+            out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
+            out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
+            out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
+            out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
+            out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
+            out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
+            out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
+            out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
+            out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
+            out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
+            out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
+            out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
+            out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
+            out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
+            out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
+            out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
+            out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
+            out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
+            out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
+            out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+            out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+            out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
+            out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
+            out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
+            out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
+            out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
+            out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
+            out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+            out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
+            out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+            out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
+            out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
+            out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
+            out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
+            out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
+            out_ext->independentResolveNone = in_ext->independentResolveNone;
+            out_ext->independentResolve = in_ext->independentResolve;
+            out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
+            out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
+            out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
+            out_ext->framebufferIntegerColorSampleCounts = in_ext->framebufferIntegerColorSampleCounts;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
         {
-            VkPhysicalDeviceTensorPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM);
-            const VkPhysicalDeviceTensorPropertiesARM *in_ext = (const VkPhysicalDeviceTensorPropertiesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM;
-            out_ext->maxTensorDimensionCount = in_ext->maxTensorDimensionCount;
-            out_ext->maxTensorElements = in_ext->maxTensorElements;
-            out_ext->maxPerDimensionTensorElements = in_ext->maxPerDimensionTensorElements;
-            out_ext->maxTensorStride = in_ext->maxTensorStride;
-            out_ext->maxTensorSize = in_ext->maxTensorSize;
-            out_ext->maxTensorShaderAccessArrayLength = in_ext->maxTensorShaderAccessArrayLength;
-            out_ext->maxTensorShaderAccessSize = in_ext->maxTensorShaderAccessSize;
-            out_ext->maxDescriptorSetStorageTensors = in_ext->maxDescriptorSetStorageTensors;
-            out_ext->maxPerStageDescriptorSetStorageTensors = in_ext->maxPerStageDescriptorSetStorageTensors;
-            out_ext->maxDescriptorSetUpdateAfterBindStorageTensors = in_ext->maxDescriptorSetUpdateAfterBindStorageTensors;
-            out_ext->maxPerStageDescriptorUpdateAfterBindStorageTensors = in_ext->maxPerStageDescriptorUpdateAfterBindStorageTensors;
-            out_ext->shaderStorageTensorArrayNonUniformIndexingNative = in_ext->shaderStorageTensorArrayNonUniformIndexingNative;
-            out_ext->shaderTensorSupportedStages = in_ext->shaderTensorSupportedStages;
+            VkPhysicalDeviceVulkan13Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES);
+            const VkPhysicalDeviceVulkan13Properties *in_ext = (const VkPhysicalDeviceVulkan13Properties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
+            out_ext->minSubgroupSize = in_ext->minSubgroupSize;
+            out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
+            out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
+            out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
+            out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
+            out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
+            out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+            out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
+            out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+            out_ext->maxInlineUniformTotalSize = in_ext->maxInlineUniformTotalSize;
+            out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
+            out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
+            out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
+            out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
+            out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
+            out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+            out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
+            out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
+            out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
+            out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
+            out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
+            out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
+            out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
+            out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
+            out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+            out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+            out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
+            out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
+            out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
+            out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
+            out_ext->maxBufferSize = in_ext->maxBufferSize;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:
         {
-            VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM);
-            const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM;
-            out_ext->tensorCaptureReplayDescriptorDataSize = in_ext->tensorCaptureReplayDescriptorDataSize;
-            out_ext->tensorViewCaptureReplayDescriptorDataSize = in_ext->tensorViewCaptureReplayDescriptorDataSize;
-            out_ext->tensorDescriptorSize = in_ext->tensorDescriptorSize;
+            VkPhysicalDeviceVulkan14Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES);
+            const VkPhysicalDeviceVulkan14Properties *in_ext = (const VkPhysicalDeviceVulkan14Properties *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES;
+            out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits;
+            out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor;
+            out_ext->supportsNonZeroFirstInstance = in_ext->supportsNonZeroFirstInstance;
+            out_ext->maxPushDescriptors = in_ext->maxPushDescriptors;
+            out_ext->dynamicRenderingLocalReadDepthStencilAttachments = in_ext->dynamicRenderingLocalReadDepthStencilAttachments;
+            out_ext->dynamicRenderingLocalReadMultisampledAttachments = in_ext->dynamicRenderingLocalReadMultisampledAttachments;
+            out_ext->earlyFragmentMultisampleCoverageAfterSampleCounting = in_ext->earlyFragmentMultisampleCoverageAfterSampleCounting;
+            out_ext->earlyFragmentSampleMaskTestBeforeSampleCounting = in_ext->earlyFragmentSampleMaskTestBeforeSampleCounting;
+            out_ext->depthStencilSwizzleOneSupport = in_ext->depthStencilSwizzleOneSupport;
+            out_ext->polygonModePointSize = in_ext->polygonModePointSize;
+            out_ext->nonStrictSinglePixelWideLinesUseParallelogram = in_ext->nonStrictSinglePixelWideLinesUseParallelogram;
+            out_ext->nonStrictWideLinesUseParallelogram = in_ext->nonStrictWideLinesUseParallelogram;
+            out_ext->blockTexelViewCompatibleMultipleLayers = in_ext->blockTexelViewCompatibleMultipleLayers;
+            out_ext->maxCombinedImageSamplerDescriptorCount = in_ext->maxCombinedImageSamplerDescriptorCount;
+            out_ext->fragmentShadingRateClampCombinerInputs = in_ext->fragmentShadingRateClampCombinerInputs;
+            out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers;
+            out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers;
+            out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs;
+            out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages;
+            out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount;
+            out_ext->pCopySrcLayouts = PtrToUlong(in_ext->pCopySrcLayouts);
+            out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount;
+            out_ext->pCopyDstLayouts = PtrToUlong(in_ext->pCopyDstLayouts);
+            memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t));
+            out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements;
             out_header = (void *)out_ext;
             break;
         }
@@ -36801,19 +36801,10 @@ static void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_con
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
-        {
-            VkQueueFamilyOwnershipTransferPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR;
-            out_ext->pNext = NULL;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES:
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
         {
-            VkQueueFamilyGlobalPriorityProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES;
+            VkQueueFamilyCheckpointProperties2NV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -36828,19 +36819,19 @@ static void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_con
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES:
         {
-            VkQueueFamilyCheckpointProperties2NV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
+            VkQueueFamilyGlobalPriorityProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
         {
-            VkQueueFamilyVideoPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR;
+            VkQueueFamilyOwnershipTransferPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -36855,6 +36846,15 @@ static void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_con
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
+        {
+            VkQueueFamilyVideoPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR;
+            out_ext->pNext = NULL;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -36891,12 +36891,21 @@ static void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyPr
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
         {
-            VkQueueFamilyOwnershipTransferPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR);
-            const VkQueueFamilyOwnershipTransferPropertiesKHR *in_ext = (const VkQueueFamilyOwnershipTransferPropertiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR;
-            out_ext->optimalImageTransferToQueueFamilies = in_ext->optimalImageTransferToQueueFamilies;
+            VkQueueFamilyCheckpointProperties2NV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV);
+            const VkQueueFamilyCheckpointProperties2NV *in_ext = (const VkQueueFamilyCheckpointProperties2NV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
+            out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+        {
+            VkQueueFamilyCheckpointPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV);
+            const VkQueueFamilyCheckpointPropertiesNV *in_ext = (const VkQueueFamilyCheckpointPropertiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
+            out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
             out_header = (void *)out_ext;
             break;
         }
@@ -36910,21 +36919,21 @@ static void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyPr
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
         {
-            VkQueueFamilyCheckpointPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV);
-            const VkQueueFamilyCheckpointPropertiesNV *in_ext = (const VkQueueFamilyCheckpointPropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
-            out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
+            VkQueueFamilyOwnershipTransferPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR);
+            const VkQueueFamilyOwnershipTransferPropertiesKHR *in_ext = (const VkQueueFamilyOwnershipTransferPropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR;
+            out_ext->optimalImageTransferToQueueFamilies = in_ext->optimalImageTransferToQueueFamilies;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
         {
-            VkQueueFamilyCheckpointProperties2NV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV);
-            const VkQueueFamilyCheckpointProperties2NV *in_ext = (const VkQueueFamilyCheckpointProperties2NV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
-            out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
+            VkQueueFamilyQueryResultStatusPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR);
+            const VkQueueFamilyQueryResultStatusPropertiesKHR *in_ext = (const VkQueueFamilyQueryResultStatusPropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR;
+            out_ext->queryResultStatusSupport = in_ext->queryResultStatusSupport;
             out_header = (void *)out_ext;
             break;
         }
@@ -36937,15 +36946,6 @@ static void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyPr
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
-        {
-            VkQueueFamilyQueryResultStatusPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR);
-            const VkQueueFamilyQueryResultStatusPropertiesKHR *in_ext = (const VkQueueFamilyQueryResultStatusPropertiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR;
-            out_ext->queryResultStatusSupport = in_ext->queryResultStatusSupport;
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             break;
         }
@@ -37119,6 +37119,18 @@ static void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_co
     {
         switch (in_header->sType)
         {
+        case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
+        {
+            VkLatencySurfaceCapabilitiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkLatencySurfaceCapabilitiesNV32 *in_ext = (const VkLatencySurfaceCapabilitiesNV32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV;
+            out_ext->pNext = NULL;
+            out_ext->presentModeCount = in_ext->presentModeCount;
+            out_ext->pPresentModes = UlongToPtr(in_ext->pPresentModes);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
         {
             VkSurfaceCapabilitiesPresentBarrierNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -37150,21 +37162,6 @@ static void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_co
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR:
-        {
-            VkSurfacePresentScalingCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkSurfacePresentScalingCapabilitiesKHR32 *in_ext = (const VkSurfacePresentScalingCapabilitiesKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR;
-            out_ext->pNext = NULL;
-            out_ext->supportedPresentScaling = in_ext->supportedPresentScaling;
-            out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX;
-            out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY;
-            out_ext->minScaledImageExtent = in_ext->minScaledImageExtent;
-            out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR:
         {
             VkSurfacePresentModeCompatibilityKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -37177,14 +37174,17 @@ static void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_co
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR:
         {
-            VkLatencySurfaceCapabilitiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkLatencySurfaceCapabilitiesNV32 *in_ext = (const VkLatencySurfaceCapabilitiesNV32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV;
+            VkSurfacePresentScalingCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkSurfacePresentScalingCapabilitiesKHR32 *in_ext = (const VkSurfacePresentScalingCapabilitiesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR;
             out_ext->pNext = NULL;
-            out_ext->presentModeCount = in_ext->presentModeCount;
-            out_ext->pPresentModes = UlongToPtr(in_ext->pPresentModes);
+            out_ext->supportedPresentScaling = in_ext->supportedPresentScaling;
+            out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX;
+            out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY;
+            out_ext->minScaledImageExtent = in_ext->minScaledImageExtent;
+            out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -37209,6 +37209,16 @@ static void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapab
     {
         switch (in_header->sType)
         {
+        case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
+        {
+            VkLatencySurfaceCapabilitiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV);
+            const VkLatencySurfaceCapabilitiesNV *in_ext = (const VkLatencySurfaceCapabilitiesNV *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV;
+            out_ext->presentModeCount = in_ext->presentModeCount;
+            out_ext->pPresentModes = PtrToUlong(in_ext->pPresentModes);
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
         {
             VkSurfaceCapabilitiesPresentBarrierNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV);
@@ -37236,19 +37246,6 @@ static void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapab
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR:
-        {
-            VkSurfacePresentScalingCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR);
-            const VkSurfacePresentScalingCapabilitiesKHR *in_ext = (const VkSurfacePresentScalingCapabilitiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR;
-            out_ext->supportedPresentScaling = in_ext->supportedPresentScaling;
-            out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX;
-            out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY;
-            out_ext->minScaledImageExtent = in_ext->minScaledImageExtent;
-            out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR:
         {
             VkSurfacePresentModeCompatibilityKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR);
@@ -37259,13 +37256,16 @@ static void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapab
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR:
         {
-            VkLatencySurfaceCapabilitiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV);
-            const VkLatencySurfaceCapabilitiesNV *in_ext = (const VkLatencySurfaceCapabilitiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV;
-            out_ext->presentModeCount = in_ext->presentModeCount;
-            out_ext->pPresentModes = PtrToUlong(in_ext->pPresentModes);
+            VkSurfacePresentScalingCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR);
+            const VkSurfacePresentScalingCapabilitiesKHR *in_ext = (const VkSurfacePresentScalingCapabilitiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR;
+            out_ext->supportedPresentScaling = in_ext->supportedPresentScaling;
+            out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX;
+            out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY;
+            out_ext->minScaledImageExtent = in_ext->minScaledImageExtent;
+            out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent;
             out_header = (void *)out_ext;
             break;
         }
@@ -37408,54 +37408,27 @@ static void convert_VkPhysicalDeviceToolProperties_array_host_to_win32(const VkP
     for (i = 0; i < count; i++)
     {
         convert_VkPhysicalDeviceToolProperties_host_to_win32(&in[i], &out[i]);
-    }
-}
-
-static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoCapabilitiesKHR32 *in, VkVideoCapabilitiesKHR *out)
-{
-    const VkBaseInStructure32 *in_header;
-    VkBaseOutStructure *out_header = (void *)out;
-
-    if (!in) return;
-
-    out->sType = in->sType;
-    out->pNext = NULL;
-
-    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
-    {
-        switch (in_header->sType)
-        {
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
-        {
-            VkVideoEncodeQuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
-            out_ext->pNext = NULL;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
-        {
-            VkVideoEncodeH264QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR;
-            out_ext->pNext = NULL;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
+    }
+}
+
+static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoCapabilitiesKHR32 *in, VkVideoCapabilitiesKHR *out)
+{
+    const VkBaseInStructure32 *in_header;
+    VkBaseOutStructure *out_header = (void *)out;
+
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+
+    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+    {
+        switch (in_header->sType)
         {
-            VkVideoEncodeH265QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR;
-            out_ext->pNext = NULL;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
         {
-            VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR;
+            VkVideoDecodeAV1CapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -37488,10 +37461,19 @@ static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_conte
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
         {
-            VkVideoDecodeAV1CapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR;
+            VkVideoEncodeAV1CapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR;
+            out_ext->pNext = NULL;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
+        {
+            VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -37515,10 +37497,19 @@ static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_conte
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
         {
-            VkVideoEncodeAV1CapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR;
+            VkVideoEncodeH264QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR;
+            out_ext->pNext = NULL;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
+        {
+            VkVideoEncodeH265QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -37533,6 +37524,15 @@ static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_conte
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
+        {
+            VkVideoEncodeQuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
+            out_ext->pNext = NULL;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -37561,42 +37561,12 @@ static void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabiliti
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
-        {
-            VkVideoEncodeQuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR);
-            const VkVideoEncodeQuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeQuantizationMapCapabilitiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
-            out_ext->maxQuantizationMapExtent = in_ext->maxQuantizationMapExtent;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
-        {
-            VkVideoEncodeH264QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR);
-            const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR;
-            out_ext->minQpDelta = in_ext->minQpDelta;
-            out_ext->maxQpDelta = in_ext->maxQpDelta;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
-        {
-            VkVideoEncodeH265QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR);
-            const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR;
-            out_ext->minQpDelta = in_ext->minQpDelta;
-            out_ext->maxQpDelta = in_ext->maxQpDelta;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
         {
-            VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR);
-            const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR;
-            out_ext->minQIndexDelta = in_ext->minQIndexDelta;
-            out_ext->maxQIndexDelta = in_ext->maxQIndexDelta;
+            VkVideoDecodeAV1CapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR);
+            const VkVideoDecodeAV1CapabilitiesKHR *in_ext = (const VkVideoDecodeAV1CapabilitiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR;
+            out_ext->maxLevel = in_ext->maxLevel;
             out_header = (void *)out_ext;
             break;
         }
@@ -37628,12 +37598,45 @@ static void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabiliti
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
         {
-            VkVideoDecodeAV1CapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR);
-            const VkVideoDecodeAV1CapabilitiesKHR *in_ext = (const VkVideoDecodeAV1CapabilitiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR;
+            VkVideoEncodeAV1CapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR);
+            const VkVideoEncodeAV1CapabilitiesKHR *in_ext = (const VkVideoEncodeAV1CapabilitiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR;
+            out_ext->flags = in_ext->flags;
             out_ext->maxLevel = in_ext->maxLevel;
+            out_ext->codedPictureAlignment = in_ext->codedPictureAlignment;
+            out_ext->maxTiles = in_ext->maxTiles;
+            out_ext->minTileSize = in_ext->minTileSize;
+            out_ext->maxTileSize = in_ext->maxTileSize;
+            out_ext->superblockSizes = in_ext->superblockSizes;
+            out_ext->maxSingleReferenceCount = in_ext->maxSingleReferenceCount;
+            out_ext->singleReferenceNameMask = in_ext->singleReferenceNameMask;
+            out_ext->maxUnidirectionalCompoundReferenceCount = in_ext->maxUnidirectionalCompoundReferenceCount;
+            out_ext->maxUnidirectionalCompoundGroup1ReferenceCount = in_ext->maxUnidirectionalCompoundGroup1ReferenceCount;
+            out_ext->unidirectionalCompoundReferenceNameMask = in_ext->unidirectionalCompoundReferenceNameMask;
+            out_ext->maxBidirectionalCompoundReferenceCount = in_ext->maxBidirectionalCompoundReferenceCount;
+            out_ext->maxBidirectionalCompoundGroup1ReferenceCount = in_ext->maxBidirectionalCompoundGroup1ReferenceCount;
+            out_ext->maxBidirectionalCompoundGroup2ReferenceCount = in_ext->maxBidirectionalCompoundGroup2ReferenceCount;
+            out_ext->bidirectionalCompoundReferenceNameMask = in_ext->bidirectionalCompoundReferenceNameMask;
+            out_ext->maxTemporalLayerCount = in_ext->maxTemporalLayerCount;
+            out_ext->maxSpatialLayerCount = in_ext->maxSpatialLayerCount;
+            out_ext->maxOperatingPoints = in_ext->maxOperatingPoints;
+            out_ext->minQIndex = in_ext->minQIndex;
+            out_ext->maxQIndex = in_ext->maxQIndex;
+            out_ext->prefersGopRemainingFrames = in_ext->prefersGopRemainingFrames;
+            out_ext->requiresGopRemainingFrames = in_ext->requiresGopRemainingFrames;
+            out_ext->stdSyntaxFlags = in_ext->stdSyntaxFlags;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
+        {
+            VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR);
+            const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR;
+            out_ext->minQIndexDelta = in_ext->minQIndexDelta;
+            out_ext->maxQIndexDelta = in_ext->maxQIndexDelta;
             out_header = (void *)out_ext;
             break;
         }
@@ -37673,35 +37676,23 @@ static void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabiliti
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
         {
-            VkVideoEncodeAV1CapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR);
-            const VkVideoEncodeAV1CapabilitiesKHR *in_ext = (const VkVideoEncodeAV1CapabilitiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR;
-            out_ext->flags = in_ext->flags;
-            out_ext->maxLevel = in_ext->maxLevel;
-            out_ext->codedPictureAlignment = in_ext->codedPictureAlignment;
-            out_ext->maxTiles = in_ext->maxTiles;
-            out_ext->minTileSize = in_ext->minTileSize;
-            out_ext->maxTileSize = in_ext->maxTileSize;
-            out_ext->superblockSizes = in_ext->superblockSizes;
-            out_ext->maxSingleReferenceCount = in_ext->maxSingleReferenceCount;
-            out_ext->singleReferenceNameMask = in_ext->singleReferenceNameMask;
-            out_ext->maxUnidirectionalCompoundReferenceCount = in_ext->maxUnidirectionalCompoundReferenceCount;
-            out_ext->maxUnidirectionalCompoundGroup1ReferenceCount = in_ext->maxUnidirectionalCompoundGroup1ReferenceCount;
-            out_ext->unidirectionalCompoundReferenceNameMask = in_ext->unidirectionalCompoundReferenceNameMask;
-            out_ext->maxBidirectionalCompoundReferenceCount = in_ext->maxBidirectionalCompoundReferenceCount;
-            out_ext->maxBidirectionalCompoundGroup1ReferenceCount = in_ext->maxBidirectionalCompoundGroup1ReferenceCount;
-            out_ext->maxBidirectionalCompoundGroup2ReferenceCount = in_ext->maxBidirectionalCompoundGroup2ReferenceCount;
-            out_ext->bidirectionalCompoundReferenceNameMask = in_ext->bidirectionalCompoundReferenceNameMask;
-            out_ext->maxTemporalLayerCount = in_ext->maxTemporalLayerCount;
-            out_ext->maxSpatialLayerCount = in_ext->maxSpatialLayerCount;
-            out_ext->maxOperatingPoints = in_ext->maxOperatingPoints;
-            out_ext->minQIndex = in_ext->minQIndex;
-            out_ext->maxQIndex = in_ext->maxQIndex;
-            out_ext->prefersGopRemainingFrames = in_ext->prefersGopRemainingFrames;
-            out_ext->requiresGopRemainingFrames = in_ext->requiresGopRemainingFrames;
-            out_ext->stdSyntaxFlags = in_ext->stdSyntaxFlags;
+            VkVideoEncodeH264QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR);
+            const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR;
+            out_ext->minQpDelta = in_ext->minQpDelta;
+            out_ext->maxQpDelta = in_ext->maxQpDelta;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
+        {
+            VkVideoEncodeH265QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR);
+            const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR;
+            out_ext->minQpDelta = in_ext->minQpDelta;
+            out_ext->maxQpDelta = in_ext->maxQpDelta;
             out_header = (void *)out_ext;
             break;
         }
@@ -37718,6 +37709,15 @@ static void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabiliti
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
+        {
+            VkVideoEncodeQuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR);
+            const VkVideoEncodeQuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeQuantizationMapCapabilitiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
+            out_ext->maxQuantizationMapExtent = in_ext->maxQuantizationMapExtent;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             break;
         }
@@ -37750,19 +37750,19 @@ static void convert_VkVideoEncodeQualityLevelPropertiesKHR_win32_to_host(struct
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
         {
-            VkVideoEncodeH264QualityLevelPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR;
+            VkVideoEncodeAV1QualityLevelPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
         {
-            VkVideoEncodeAV1QualityLevelPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR;
+            VkVideoEncodeH264QualityLevelPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -37789,23 +37789,6 @@ static void convert_VkVideoEncodeQualityLevelPropertiesKHR_host_to_win32(const V
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
-        {
-            VkVideoEncodeH264QualityLevelPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR);
-            const VkVideoEncodeH264QualityLevelPropertiesKHR *in_ext = (const VkVideoEncodeH264QualityLevelPropertiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR;
-            out_ext->preferredRateControlFlags = in_ext->preferredRateControlFlags;
-            out_ext->preferredGopFrameCount = in_ext->preferredGopFrameCount;
-            out_ext->preferredIdrPeriod = in_ext->preferredIdrPeriod;
-            out_ext->preferredConsecutiveBFrameCount = in_ext->preferredConsecutiveBFrameCount;
-            out_ext->preferredTemporalLayerCount = in_ext->preferredTemporalLayerCount;
-            out_ext->preferredConstantQp = in_ext->preferredConstantQp;
-            out_ext->preferredMaxL0ReferenceCount = in_ext->preferredMaxL0ReferenceCount;
-            out_ext->preferredMaxL1ReferenceCount = in_ext->preferredMaxL1ReferenceCount;
-            out_ext->preferredStdEntropyCodingModeFlag = in_ext->preferredStdEntropyCodingModeFlag;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
         {
             VkVideoEncodeAV1QualityLevelPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR);
@@ -37829,6 +37812,23 @@ static void convert_VkVideoEncodeQualityLevelPropertiesKHR_host_to_win32(const V
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
+        {
+            VkVideoEncodeH264QualityLevelPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR);
+            const VkVideoEncodeH264QualityLevelPropertiesKHR *in_ext = (const VkVideoEncodeH264QualityLevelPropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR;
+            out_ext->preferredRateControlFlags = in_ext->preferredRateControlFlags;
+            out_ext->preferredGopFrameCount = in_ext->preferredGopFrameCount;
+            out_ext->preferredIdrPeriod = in_ext->preferredIdrPeriod;
+            out_ext->preferredConsecutiveBFrameCount = in_ext->preferredConsecutiveBFrameCount;
+            out_ext->preferredTemporalLayerCount = in_ext->preferredTemporalLayerCount;
+            out_ext->preferredConstantQp = in_ext->preferredConstantQp;
+            out_ext->preferredMaxL0ReferenceCount = in_ext->preferredMaxL0ReferenceCount;
+            out_ext->preferredMaxL1ReferenceCount = in_ext->preferredMaxL1ReferenceCount;
+            out_ext->preferredStdEntropyCodingModeFlag = in_ext->preferredStdEntropyCodingModeFlag;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             break;
         }
@@ -37883,10 +37883,10 @@ static void convert_VkVideoFormatPropertiesKHR_win32_to_host(struct conversion_c
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
         {
-            VkVideoFormatQuantizationMapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+            VkVideoFormatAV1QuantizationMapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -37901,10 +37901,10 @@ static void convert_VkVideoFormatPropertiesKHR_win32_to_host(struct conversion_c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
         {
-            VkVideoFormatAV1QuantizationMapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR;
+            VkVideoFormatQuantizationMapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -37951,12 +37951,12 @@ static void convert_VkVideoFormatPropertiesKHR_host_to_win32(const VkVideoFormat
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
         {
-            VkVideoFormatQuantizationMapPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR);
-            const VkVideoFormatQuantizationMapPropertiesKHR *in_ext = (const VkVideoFormatQuantizationMapPropertiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
-            out_ext->quantizationMapTexelSize = in_ext->quantizationMapTexelSize;
+            VkVideoFormatAV1QuantizationMapPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR);
+            const VkVideoFormatAV1QuantizationMapPropertiesKHR *in_ext = (const VkVideoFormatAV1QuantizationMapPropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR;
+            out_ext->compatibleSuperblockSizes = in_ext->compatibleSuperblockSizes;
             out_header = (void *)out_ext;
             break;
         }
@@ -37969,12 +37969,12 @@ static void convert_VkVideoFormatPropertiesKHR_host_to_win32(const VkVideoFormat
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
         {
-            VkVideoFormatAV1QuantizationMapPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR);
-            const VkVideoFormatAV1QuantizationMapPropertiesKHR *in_ext = (const VkVideoFormatAV1QuantizationMapPropertiesKHR *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR;
-            out_ext->compatibleSuperblockSizes = in_ext->compatibleSuperblockSizes;
+            VkVideoFormatQuantizationMapPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR);
+            const VkVideoFormatQuantizationMapPropertiesKHR *in_ext = (const VkVideoFormatQuantizationMapPropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+            out_ext->quantizationMapTexelSize = in_ext->quantizationMapTexelSize;
             out_header = (void *)out_ext;
             break;
         }
@@ -38898,20 +38898,6 @@ static void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ct
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
-        {
-            VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
-            out_ext->pNext = NULL;
-            out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
-            out_ext->pWaitSemaphoreValues = UlongToPtr(in_ext->pWaitSemaphoreValues);
-            out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
-            out_ext->pSignalSemaphoreValues = UlongToPtr(in_ext->pSignalSemaphoreValues);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
         {
             VkFrameBoundaryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -38943,6 +38929,20 @@ static void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ct
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
+        {
+            VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
+            out_ext->pNext = NULL;
+            out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
+            out_ext->pWaitSemaphoreValues = UlongToPtr(in_ext->pWaitSemaphoreValues);
+            out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
+            out_ext->pSignalSemaphoreValues = UlongToPtr(in_ext->pSignalSemaphoreValues);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -39021,18 +39021,6 @@ static void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conversion_c
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
-        {
-            VkPresentRegionsKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPresentRegionsKHR32 *in_ext = (const VkPresentRegionsKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
-            out_ext->pNext = NULL;
-            out_ext->swapchainCount = in_ext->swapchainCount;
-            out_ext->pRegions = convert_VkPresentRegionKHR_array_win32_to_host(ctx, (const VkPresentRegionKHR32 *)UlongToPtr(in_ext->pRegions), in_ext->swapchainCount);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
         {
             VkDeviceGroupPresentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -39046,14 +39034,33 @@ static void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conversion_c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
+        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
         {
-            VkPresentIdKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPresentIdKHR32 *in_ext = (const VkPresentIdKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR;
+            VkFrameBoundaryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkFrameBoundaryEXT32 *in_ext = (const VkFrameBoundaryEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT;
             out_ext->pNext = NULL;
-            out_ext->swapchainCount = in_ext->swapchainCount;
-            out_ext->pPresentIds = UlongToPtr(in_ext->pPresentIds);
+            out_ext->flags = in_ext->flags;
+            out_ext->frameID = in_ext->frameID;
+            out_ext->imageCount = in_ext->imageCount;
+            out_ext->pImages = UlongToPtr(in_ext->pImages);
+            out_ext->bufferCount = in_ext->bufferCount;
+            out_ext->pBuffers = UlongToPtr(in_ext->pBuffers);
+            out_ext->tagName = in_ext->tagName;
+            out_ext->tagSize = in_ext->tagSize;
+            out_ext->pTag = UlongToPtr(in_ext->pTag);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
+        {
+            VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM;
+            out_ext->pNext = NULL;
+            out_ext->tensorCount = in_ext->tensorCount;
+            out_ext->pTensors = UlongToPtr(in_ext->pTensors);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -39070,21 +39077,26 @@ static void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conversion_c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
+        case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
         {
-            VkFrameBoundaryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkFrameBoundaryEXT32 *in_ext = (const VkFrameBoundaryEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT;
+            VkPresentIdKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPresentIdKHR32 *in_ext = (const VkPresentIdKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR;
             out_ext->pNext = NULL;
-            out_ext->flags = in_ext->flags;
-            out_ext->frameID = in_ext->frameID;
-            out_ext->imageCount = in_ext->imageCount;
-            out_ext->pImages = UlongToPtr(in_ext->pImages);
-            out_ext->bufferCount = in_ext->bufferCount;
-            out_ext->pBuffers = UlongToPtr(in_ext->pBuffers);
-            out_ext->tagName = in_ext->tagName;
-            out_ext->tagSize = in_ext->tagSize;
-            out_ext->pTag = UlongToPtr(in_ext->pTag);
+            out_ext->swapchainCount = in_ext->swapchainCount;
+            out_ext->pPresentIds = UlongToPtr(in_ext->pPresentIds);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+        {
+            VkPresentRegionsKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPresentRegionsKHR32 *in_ext = (const VkPresentRegionsKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
+            out_ext->pNext = NULL;
+            out_ext->swapchainCount = in_ext->swapchainCount;
+            out_ext->pRegions = convert_VkPresentRegionKHR_array_win32_to_host(ctx, (const VkPresentRegionKHR32 *)UlongToPtr(in_ext->pRegions), in_ext->swapchainCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -39113,18 +39125,6 @@ static void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conversion_c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
-        {
-            VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM;
-            out_ext->pNext = NULL;
-            out_ext->tensorCount = in_ext->tensorCount;
-            out_ext->pTensors = UlongToPtr(in_ext->pTensors);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -39204,42 +39204,6 @@ static void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
-        {
-            VkProtectedSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkProtectedSubmitInfo32 *in_ext = (const VkProtectedSubmitInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO;
-            out_ext->pNext = NULL;
-            out_ext->protectedSubmit = in_ext->protectedSubmit;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
-        {
-            VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
-            out_ext->pNext = NULL;
-            out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
-            out_ext->pWaitSemaphoreValues = UlongToPtr(in_ext->pWaitSemaphoreValues);
-            out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
-            out_ext->pSignalSemaphoreValues = UlongToPtr(in_ext->pSignalSemaphoreValues);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
-        {
-            VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->counterPassIndex = in_ext->counterPassIndex;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
         {
             VkFrameBoundaryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -39259,6 +39223,18 @@ static void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, c
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
+        {
+            VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM;
+            out_ext->pNext = NULL;
+            out_ext->tensorCount = in_ext->tensorCount;
+            out_ext->pTensors = UlongToPtr(in_ext->pTensors);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV:
         {
             VkLatencySubmissionPresentIdNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -39270,14 +39246,38 @@ static void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, c
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
+        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
         {
-            VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM;
+            VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->tensorCount = in_ext->tensorCount;
-            out_ext->pTensors = UlongToPtr(in_ext->pTensors);
+            out_ext->counterPassIndex = in_ext->counterPassIndex;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+        {
+            VkProtectedSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkProtectedSubmitInfo32 *in_ext = (const VkProtectedSubmitInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO;
+            out_ext->pNext = NULL;
+            out_ext->protectedSubmit = in_ext->protectedSubmit;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
+        {
+            VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
+            out_ext->pNext = NULL;
+            out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
+            out_ext->pWaitSemaphoreValues = UlongToPtr(in_ext->pWaitSemaphoreValues);
+            out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
+            out_ext->pSignalSemaphoreValues = UlongToPtr(in_ext->pSignalSemaphoreValues);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -39472,17 +39472,6 @@ static void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx,
     {
         switch (in_header->sType)
         {
-        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
-        {
-            VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->counterPassIndex = in_ext->counterPassIndex;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
         {
             VkFrameBoundaryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -39502,6 +39491,18 @@ static void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx,
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
+        {
+            VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM;
+            out_ext->pNext = NULL;
+            out_ext->tensorCount = in_ext->tensorCount;
+            out_ext->pTensors = UlongToPtr(in_ext->pTensors);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV:
         {
             VkLatencySubmissionPresentIdNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -39513,14 +39514,13 @@ static void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx,
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
+        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
         {
-            VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM;
+            VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->tensorCount = in_ext->tensorCount;
-            out_ext->pTensors = UlongToPtr(in_ext->pTensors);
+            out_ext->counterPassIndex = in_ext->counterPassIndex;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;

[PATCH v2 5/5] winevulkan: Avoid converting unexposed extensions structs.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/winevulkan/make_vulkan     |  13 +-
 dlls/winevulkan/vulkan_thunks.c | 203 ++------------------------------
 2 files changed, 19 insertions(+), 197 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 4b7c553a44e..6eb466b8937 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -1957,12 +1957,18 @@ class VkStruct(Sequence):
                 structs[member.type].alias.set_order(self.order, structs)
             structs[member.type].set_order(self.order, structs)

+    @property
+    def extension(self):
+        return self.registry.types[self.name]["extension"]
+
     @property
     def struct_extensions(self):
         if self._extensions is None:
             self._extensions = []

def is_struct_extension(s):
+                if s.extension in UNEXPOSED_EXTENSIONS:
+                    return False
                 return not s.alias and self.name in s.structextends

structs = sorted(self.registry.structs, key=lambda s: s.name)
@@ -3429,8 +3435,9 @@ class VkRegistry(object):
                     # We don't even parse <type category="include"> tags.
                     # Therefore just skip any types that aren't found.
                     if t.attrib["name"] in self.types:
-                        type_info = self.types[t.attrib["name"]]["data"]
-                        self._require_type(type_info)
+                        type_info = self.types[t.attrib["name"]]
+                        type_info["extension"] = ext_name
+                        self._require_type(type_info["data"])
                 feature = require.attrib.get("feature")
                 if feature and not self._is_feature_supported(feature):
                     continue
@@ -3519,6 +3526,7 @@ class VkRegistry(object):
             type_info = {}
             type_info["category"] = t.attrib.get("category", None)
             type_info["requires"] = t.attrib.get("requires", None)
+            type_info["extension"] = None

# We parse aliases in a second pass when we know more.
             alias = t.attrib.get("alias")
@@ -3626,6 +3634,7 @@ class VkRegistry(object):
             type_info = {}
             type_info["category"] = t.attrib.get("category")
             type_info["name"] = t.attrib.get("name")
+            type_info["extension"] = None

alias = t.attrib.get("alias")

diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index 3a3549f7dda..ac5604c80e5 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -3102,15 +3102,6 @@ typedef struct VkExportMemoryAllocateInfo32
 } VkExportMemoryAllocateInfo32;
 typedef VkExportMemoryAllocateInfo32 VkExportMemoryAllocateInfoKHR32;

-typedef struct VkExportMemoryWin32HandleInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    PTR32 pAttributes;
-    DWORD dwAccess;
-    LPCWSTR name;
-} VkExportMemoryWin32HandleInfoKHR32;
-
 typedef struct VkExportSemaphoreCreateInfo32
 {
     VkStructureType sType;
@@ -3632,15 +3623,6 @@ typedef struct VkImportMemoryHostPointerInfoEXT32
     PTR32 pHostPointer;
 } VkImportMemoryHostPointerInfoEXT32;

-typedef struct VkImportMemoryWin32HandleInfoKHR32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkExternalMemoryHandleTypeFlagBits handleType;
-    HANDLE handle;
-    LPCWSTR name;
-} VkImportMemoryWin32HandleInfoKHR32;
-
 typedef struct VkIndirectCommandsLayoutCreateInfoEXT32
 {
     VkStructureType sType;
@@ -3817,13 +3799,6 @@ typedef struct VkMemoryMapInfo32
 } VkMemoryMapInfo32;
 typedef VkMemoryMapInfo32 VkMemoryMapInfoKHR32;

-typedef struct VkMemoryMapPlacedInfoEXT32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    PTR32 pPlacedAddress;
-} VkMemoryMapPlacedInfoEXT32;
-
 typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo32
 {
     VkStructureType sType;
@@ -5482,22 +5457,6 @@ typedef struct VkPhysicalDeviceMaintenance9PropertiesKHR32
     VkDefaultVertexAttributeValueKHR defaultVertexAttributeValue;
 } VkPhysicalDeviceMaintenance9PropertiesKHR32;

-typedef struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkBool32 memoryMapPlaced;
-    VkBool32 memoryMapRangePlaced;
-    VkBool32 memoryUnmapReserve;
-} VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32;
-
-typedef struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32
-{
-    VkStructureType sType;
-    PTR32 pNext;
-    VkDeviceSize DECLSPEC_ALIGN(8) minPlacedMemoryMapAlignment;
-} VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32;
-
 typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT32
 {
     VkStructureType sType;
@@ -9698,19 +9657,6 @@ static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
-        {
-            VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkExportMemoryWin32HandleInfoKHR32 *in_ext = (const VkExportMemoryWin32HandleInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->pAttributes = UlongToPtr(in_ext->pAttributes);
-            out_ext->dwAccess = in_ext->dwAccess;
-            out_ext->name = in_ext->name;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
         {
             VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -9723,19 +9669,6 @@ static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
-        {
-            VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkImportMemoryWin32HandleInfoKHR32 *in_ext = (const VkImportMemoryWin32HandleInfoKHR32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
-            out_ext->pNext = NULL;
-            out_ext->handleType = in_ext->handleType;
-            out_ext->handle = in_ext->handle;
-            out_ext->name = in_ext->name;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
         {
             VkMemoryAllocateFlagsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -17425,19 +17358,6 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
-        {
-            VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
-            out_ext->pNext = NULL;
-            out_ext->memoryMapPlaced = in_ext->memoryMapPlaced;
-            out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced;
-            out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
         {
             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -20329,19 +20249,6 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
-        {
-            VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
-            out_ext->pNext = NULL;
-            out_ext->memoryMapPlaced = in_ext->memoryMapPlaced;
-            out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced;
-            out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
         {
             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -29852,19 +29759,6 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
-        {
-            VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
-            out_ext->pNext = NULL;
-            out_ext->memoryMapPlaced = in_ext->memoryMapPlaced;
-            out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced;
-            out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
         {
             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -32376,17 +32270,6 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
-        {
-            VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT);
-            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
-            out_ext->memoryMapPlaced = in_ext->memoryMapPlaced;
-            out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced;
-            out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
         {
             VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV);
@@ -34838,15 +34721,6 @@ static void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
-        {
-            VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT;
-            out_ext->pNext = NULL;
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
         {
             VkPhysicalDeviceMemoryDecompressionPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -35924,15 +35798,6 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
-        {
-            VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT);
-            const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT;
-            out_ext->minPlacedMemoryMapAlignment = in_ext->minPlacedMemoryMapAlignment;
-            out_header = (void *)out_ext;
-            break;
-        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
         {
             VkPhysicalDeviceMemoryDecompressionPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV);
@@ -38472,11 +38337,8 @@ static void convert_VkMemoryMapInfo_win64_to_host(const VkMemoryMapInfo *in, VkM
 }
 #endif /* _WIN64 */

-static void convert_VkMemoryMapInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryMapInfo32 *in, VkMemoryMapInfo *out)
+static void convert_VkMemoryMapInfo_win32_to_host(const VkMemoryMapInfo32 *in, VkMemoryMapInfo *out)
 {
-    const VkBaseInStructure32 *in_header;
-    VkBaseOutStructure *out_header = (void *)out;
-
     if (!in) return;

out->sType = in->sType;
@@ -38485,34 +38347,12 @@ static void convert_VkMemoryMapInfo_win32_to_host(struct conversion_context *ctx
     out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory;
     out->offset = in->offset;
     out->size = in->size;
-
-    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
-    {
-        switch (in_header->sType)
-        {
-        case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
-        {
-            VkMemoryMapPlacedInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkMemoryMapPlacedInfoEXT32 *in_ext = (const VkMemoryMapPlacedInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->pPlacedAddress = UlongToPtr(in_ext->pPlacedAddress);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        default:
-            FIXME("Unhandled sType %u.\n", in_header->sType);
-            break;
-        }
-    }
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
 }

-static void convert_VkMemoryMapInfo_win32_to_unwrapped_host(struct conversion_context *ctx, const VkMemoryMapInfo32 *in, VkMemoryMapInfo *out)
+static void convert_VkMemoryMapInfo_win32_to_unwrapped_host(const VkMemoryMapInfo32 *in, VkMemoryMapInfo *out)
 {
-    const VkBaseInStructure32 *in_header;
-    VkBaseOutStructure *out_header = (void *)out;
-
     if (!in) return;

out->sType = in->sType;
@@ -38521,27 +38361,8 @@ static void convert_VkMemoryMapInfo_win32_to_unwrapped_host(struct conversion_co
     out->memory = in->memory;
     out->offset = in->offset;
     out->size = in->size;
-
-    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
-    {
-        switch (in_header->sType)
-        {
-        case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
-        {
-            VkMemoryMapPlacedInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            const VkMemoryMapPlacedInfoEXT32 *in_ext = (const VkMemoryMapPlacedInfoEXT32 *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT;
-            out_ext->pNext = NULL;
-            out_ext->pPlacedAddress = UlongToPtr(in_ext->pPlacedAddress);
-            out_header->pNext = (void *)out_ext;
-            out_header = (void *)out_ext;
-            break;
-        }
-        default:
-            FIXME("Unhandled sType %u.\n", in_header->sType);
-            break;
-        }
-    }
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
 }

#ifdef _WIN64
@@ -57160,17 +56981,13 @@ static NTSTATUS thunk32_vkMapMemory2(void *args)
     } *params = args;
     VkMemoryMapInfo pMemoryMapInfo_host;
     void *ppData_host;
-    struct conversion_context local_ctx;
-    struct conversion_context *ctx = &local_ctx;

TRACE("%#x, %#x, %#x\n", params->device, params->pMemoryMapInfo, params->ppData);

-    init_conversion_context(ctx);
-    convert_VkMemoryMapInfo_win32_to_host(ctx, (const VkMemoryMapInfo32 *)UlongToPtr(params->pMemoryMapInfo), &pMemoryMapInfo_host);
+    convert_VkMemoryMapInfo_win32_to_host((const VkMemoryMapInfo32 *)UlongToPtr(params->pMemoryMapInfo), &pMemoryMapInfo_host);
     ppData_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->ppData));
     params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkMapMemory2(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pMemoryMapInfo_host, &ppData_host);
     *(PTR32 *)UlongToPtr(params->ppData) = PtrToUlong(ppData_host);
-    free_conversion_context(ctx);
     return STATUS_SUCCESS;
 }

@@ -57197,17 +57014,13 @@ static NTSTATUS thunk32_vkMapMemory2KHR(void *args)
     } *params = args;
     VkMemoryMapInfo pMemoryMapInfo_host;
     void *ppData_host;
-    struct conversion_context local_ctx;
-    struct conversion_context *ctx = &local_ctx;

TRACE("%#x, %#x, %#x\n", params->device, params->pMemoryMapInfo, params->ppData);

-    init_conversion_context(ctx);
-    convert_VkMemoryMapInfo_win32_to_unwrapped_host(ctx, (const VkMemoryMapInfo32 *)UlongToPtr(params->pMemoryMapInfo), &pMemoryMapInfo_host);
+    convert_VkMemoryMapInfo_win32_to_unwrapped_host((const VkMemoryMapInfo32 *)UlongToPtr(params->pMemoryMapInfo), &pMemoryMapInfo_host);
     ppData_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->ppData));
     params->result = vk_funcs->p_vkMapMemory2KHR((VkDevice)UlongToPtr(params->device), &pMemoryMapInfo_host, &ppData_host);
     *(PTR32 *)UlongToPtr(params->ppData) = PtrToUlong(ppData_host);
-    free_conversion_context(ctx);
     return STATUS_SUCCESS;
 }

[Rémi Bernon (＠rbernon)]

v2: Don't expose VK_EXT_map_memory_placed and strip its struct conversions too, it's not used from PE-side.