diff --git a/layers/vulkansc/generated/command_validation.cpp b/layers/vulkansc/generated/command_validation.cpp
index 785cfd0aa..ea05cea1a 100644
--- a/layers/vulkansc/generated/command_validation.cpp
+++ b/layers/vulkansc/generated/command_validation.cpp
@@ -24,7 +24,7 @@
 #include "command_validation.h"
 #include "containers/custom_containers.h"
 
-extern const char *kVUIDUndefined;
+extern const char* kVUIDUndefined;
 
 using Func = vvl::Func;
 // clang-format off
@@ -2888,7 +2888,7 @@ return kCommandValidationTable;
 }
 // clang-format on
 
-const CommandValidationInfo &GetCommandValidationInfo(vvl::Func command) {
+const CommandValidationInfo& GetCommandValidationInfo(vvl::Func command) {
     auto info_it = GetCommandValidationTable().find(command);
     assert(info_it != GetCommandValidationTable().end());
     return info_it->second;
diff --git a/layers/vulkansc/generated/device_features.cpp b/layers/vulkansc/generated/device_features.cpp
index 8cdf57da5..94ee83aeb 100644
--- a/layers/vulkansc/generated/device_features.cpp
+++ b/layers/vulkansc/generated/device_features.cpp
@@ -26,15 +26,15 @@
 #include "generated/vk_extension_helper.h"
 #include <vulkan/utility/vk_struct_helper.hpp>
 
-void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatures *features, const APIVersion &api_version) {
+void GetEnabledDeviceFeatures(const VkDeviceCreateInfo* pCreateInfo, DeviceFeatures* features, const APIVersion& api_version) {
     // Initialize all to false
     *features = {};
 
     // handle VkPhysicalDeviceFeatures specially as it is not part of the pNext chain,
     // and when it is (through VkPhysicalDeviceFeatures2), it requires an extra indirection.
-    const VkPhysicalDeviceFeatures *core_features = pCreateInfo->pEnabledFeatures;
+    const VkPhysicalDeviceFeatures* core_features = pCreateInfo->pEnabledFeatures;
     if (core_features == nullptr) {
-        const VkPhysicalDeviceFeatures2 *features2 = vku::FindStructInPNextChain<VkPhysicalDeviceFeatures2>(pCreateInfo->pNext);
+        const VkPhysicalDeviceFeatures2* features2 = vku::FindStructInPNextChain<VkPhysicalDeviceFeatures2>(pCreateInfo->pNext);
         if (features2 != nullptr) {
             core_features = &features2->features;
         }
@@ -97,18 +97,18 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
         features->inheritedQueries = core_features->inheritedQueries == VK_TRUE;
     }
 
-    for (const VkBaseInStructure *pNext = reinterpret_cast<const VkBaseInStructure *>(pCreateInfo->pNext); pNext != nullptr;
+    for (const VkBaseInStructure* pNext = reinterpret_cast<const VkBaseInStructure*>(pCreateInfo->pNext); pNext != nullptr;
          pNext = pNext->pNext) {
         switch (pNext->sType) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
-                const VkPhysicalDeviceProtectedMemoryFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures *>(pNext);
+                const VkPhysicalDeviceProtectedMemoryFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(pNext);
                 features->protectedMemory |= enabled->protectedMemory == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
-                const VkPhysicalDevice16BitStorageFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures *>(pNext);
+                const VkPhysicalDevice16BitStorageFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(pNext);
                 features->storageBuffer16BitAccess |= enabled->storageBuffer16BitAccess == VK_TRUE;
                 features->uniformAndStorageBuffer16BitAccess |= enabled->uniformAndStorageBuffer16BitAccess == VK_TRUE;
                 features->storagePushConstant16 |= enabled->storagePushConstant16 == VK_TRUE;
@@ -116,34 +116,34 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
-                const VkPhysicalDeviceVariablePointersFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures *>(pNext);
+                const VkPhysicalDeviceVariablePointersFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(pNext);
                 features->variablePointersStorageBuffer |= enabled->variablePointersStorageBuffer == VK_TRUE;
                 features->variablePointers |= enabled->variablePointers == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
-                const VkPhysicalDeviceSamplerYcbcrConversionFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(pNext);
+                const VkPhysicalDeviceSamplerYcbcrConversionFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(pNext);
                 features->samplerYcbcrConversion |= enabled->samplerYcbcrConversion == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
-                const VkPhysicalDeviceMultiviewFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures *>(pNext);
+                const VkPhysicalDeviceMultiviewFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(pNext);
                 features->multiview |= enabled->multiview == VK_TRUE;
                 features->multiviewGeometryShader |= enabled->multiviewGeometryShader == VK_TRUE;
                 features->multiviewTessellationShader |= enabled->multiviewTessellationShader == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
-                const VkPhysicalDeviceShaderDrawParametersFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures *>(pNext);
+                const VkPhysicalDeviceShaderDrawParametersFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(pNext);
                 features->shaderDrawParameters |= enabled->shaderDrawParameters == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
-                const VkPhysicalDeviceVulkan11Features *enabled = reinterpret_cast<const VkPhysicalDeviceVulkan11Features *>(pNext);
+                const VkPhysicalDeviceVulkan11Features* enabled = reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(pNext);
                 features->storageBuffer16BitAccess |= enabled->storageBuffer16BitAccess == VK_TRUE;
                 features->uniformAndStorageBuffer16BitAccess |= enabled->uniformAndStorageBuffer16BitAccess == VK_TRUE;
                 features->storagePushConstant16 |= enabled->storagePushConstant16 == VK_TRUE;
@@ -159,7 +159,7 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
-                const VkPhysicalDeviceVulkan12Features *enabled = reinterpret_cast<const VkPhysicalDeviceVulkan12Features *>(pNext);
+                const VkPhysicalDeviceVulkan12Features* enabled = reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(pNext);
                 features->samplerMirrorClampToEdge |= enabled->samplerMirrorClampToEdge == VK_TRUE;
                 features->drawIndirectCount |= enabled->drawIndirectCount == VK_TRUE;
                 features->storageBuffer8BitAccess |= enabled->storageBuffer8BitAccess == VK_TRUE;
@@ -228,8 +228,8 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
-                const VkPhysicalDeviceVulkanMemoryModelFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures *>(pNext);
+                const VkPhysicalDeviceVulkanMemoryModelFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(pNext);
                 features->vulkanMemoryModel |= enabled->vulkanMemoryModel == VK_TRUE;
                 features->vulkanMemoryModelDeviceScope |= enabled->vulkanMemoryModelDeviceScope == VK_TRUE;
                 features->vulkanMemoryModelAvailabilityVisibilityChains |=
@@ -237,50 +237,50 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
-                const VkPhysicalDeviceHostQueryResetFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures *>(pNext);
+                const VkPhysicalDeviceHostQueryResetFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(pNext);
                 features->hostQueryReset |= enabled->hostQueryReset == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
-                const VkPhysicalDeviceTimelineSemaphoreFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures *>(pNext);
+                const VkPhysicalDeviceTimelineSemaphoreFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(pNext);
                 features->timelineSemaphore |= enabled->timelineSemaphore == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
-                const VkPhysicalDeviceBufferDeviceAddressFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures *>(pNext);
+                const VkPhysicalDeviceBufferDeviceAddressFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(pNext);
                 features->bufferDeviceAddress |= enabled->bufferDeviceAddress == VK_TRUE;
                 features->bufferDeviceAddressCaptureReplay |= enabled->bufferDeviceAddressCaptureReplay == VK_TRUE;
                 features->bufferDeviceAddressMultiDevice |= enabled->bufferDeviceAddressMultiDevice == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
-                const VkPhysicalDevice8BitStorageFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures *>(pNext);
+                const VkPhysicalDevice8BitStorageFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(pNext);
                 features->storageBuffer8BitAccess |= enabled->storageBuffer8BitAccess == VK_TRUE;
                 features->uniformAndStorageBuffer8BitAccess |= enabled->uniformAndStorageBuffer8BitAccess == VK_TRUE;
                 features->storagePushConstant8 |= enabled->storagePushConstant8 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
-                const VkPhysicalDeviceShaderAtomicInt64Features *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features *>(pNext);
+                const VkPhysicalDeviceShaderAtomicInt64Features* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(pNext);
                 features->shaderBufferInt64Atomics |= enabled->shaderBufferInt64Atomics == VK_TRUE;
                 features->shaderSharedInt64Atomics |= enabled->shaderSharedInt64Atomics == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
-                const VkPhysicalDeviceShaderFloat16Int8Features *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features *>(pNext);
+                const VkPhysicalDeviceShaderFloat16Int8Features* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(pNext);
                 features->shaderFloat16 |= enabled->shaderFloat16 == VK_TRUE;
                 features->shaderInt8 |= enabled->shaderInt8 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
-                const VkPhysicalDeviceDescriptorIndexingFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures *>(pNext);
+                const VkPhysicalDeviceDescriptorIndexingFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(pNext);
                 features->shaderInputAttachmentArrayDynamicIndexing |=
                     enabled->shaderInputAttachmentArrayDynamicIndexing == VK_TRUE;
                 features->shaderUniformTexelBufferArrayDynamicIndexing |=
@@ -321,37 +321,37 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
-                const VkPhysicalDeviceScalarBlockLayoutFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures *>(pNext);
+                const VkPhysicalDeviceScalarBlockLayoutFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(pNext);
                 features->scalarBlockLayout |= enabled->scalarBlockLayout == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
-                const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(pNext);
+                const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(pNext);
                 features->uniformBufferStandardLayout |= enabled->uniformBufferStandardLayout == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
-                const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(pNext);
+                const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(pNext);
                 features->shaderSubgroupExtendedTypes |= enabled->shaderSubgroupExtendedTypes == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
-                const VkPhysicalDeviceImagelessFramebufferFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures *>(pNext);
+                const VkPhysicalDeviceImagelessFramebufferFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(pNext);
                 features->imagelessFramebuffer |= enabled->imagelessFramebuffer == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
-                const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(pNext);
+                const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(pNext);
                 features->separateDepthStencilLayouts |= enabled->separateDepthStencilLayouts == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
-                const VkPhysicalDeviceVulkan13Features *enabled = reinterpret_cast<const VkPhysicalDeviceVulkan13Features *>(pNext);
+                const VkPhysicalDeviceVulkan13Features* enabled = reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(pNext);
                 features->robustImageAccess |= enabled->robustImageAccess == VK_TRUE;
                 features->inlineUniformBlock |= enabled->inlineUniformBlock == VK_TRUE;
                 features->descriptorBindingInlineUniformBlockUpdateAfterBind |=
@@ -371,88 +371,88 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
-                const VkPhysicalDevicePrivateDataFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures *>(pNext);
+                const VkPhysicalDevicePrivateDataFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(pNext);
                 features->privateData |= enabled->privateData == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
-                const VkPhysicalDeviceSynchronization2Features *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceSynchronization2Features *>(pNext);
+                const VkPhysicalDeviceSynchronization2Features* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(pNext);
                 features->synchronization2 |= enabled->synchronization2 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
-                const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *>(pNext);
+                const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(pNext);
                 features->textureCompressionASTC_HDR |= enabled->textureCompressionASTC_HDR == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
-                const VkPhysicalDeviceMaintenance4Features *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance4Features *>(pNext);
+                const VkPhysicalDeviceMaintenance4Features* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(pNext);
                 features->maintenance4 |= enabled->maintenance4 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
-                const VkPhysicalDeviceShaderTerminateInvocationFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures *>(pNext);
+                const VkPhysicalDeviceShaderTerminateInvocationFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(pNext);
                 features->shaderTerminateInvocation |= enabled->shaderTerminateInvocation == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
-                const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *>(pNext);
+                const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(pNext);
                 features->shaderDemoteToHelperInvocation |= enabled->shaderDemoteToHelperInvocation == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
-                const VkPhysicalDevicePipelineCreationCacheControlFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures *>(pNext);
+                const VkPhysicalDevicePipelineCreationCacheControlFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(pNext);
                 features->pipelineCreationCacheControl |= enabled->pipelineCreationCacheControl == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
-                const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *>(pNext);
+                const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(pNext);
                 features->shaderZeroInitializeWorkgroupMemory |= enabled->shaderZeroInitializeWorkgroupMemory == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
-                const VkPhysicalDeviceImageRobustnessFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures *>(pNext);
+                const VkPhysicalDeviceImageRobustnessFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(pNext);
                 features->robustImageAccess |= enabled->robustImageAccess == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
-                const VkPhysicalDeviceSubgroupSizeControlFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures *>(pNext);
+                const VkPhysicalDeviceSubgroupSizeControlFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(pNext);
                 features->subgroupSizeControl |= enabled->subgroupSizeControl == VK_TRUE;
                 features->computeFullSubgroups |= enabled->computeFullSubgroups == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
-                const VkPhysicalDeviceInlineUniformBlockFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures *>(pNext);
+                const VkPhysicalDeviceInlineUniformBlockFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(pNext);
                 features->inlineUniformBlock |= enabled->inlineUniformBlock == VK_TRUE;
                 features->descriptorBindingInlineUniformBlockUpdateAfterBind |=
                     enabled->descriptorBindingInlineUniformBlockUpdateAfterBind == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
-                const VkPhysicalDeviceShaderIntegerDotProductFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures *>(pNext);
+                const VkPhysicalDeviceShaderIntegerDotProductFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(pNext);
                 features->shaderIntegerDotProduct |= enabled->shaderIntegerDotProduct == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
-                const VkPhysicalDeviceDynamicRenderingFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures *>(pNext);
+                const VkPhysicalDeviceDynamicRenderingFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(pNext);
                 features->dynamicRendering |= enabled->dynamicRendering == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: {
-                const VkPhysicalDeviceVulkan14Features *enabled = reinterpret_cast<const VkPhysicalDeviceVulkan14Features *>(pNext);
+                const VkPhysicalDeviceVulkan14Features* enabled = reinterpret_cast<const VkPhysicalDeviceVulkan14Features*>(pNext);
                 features->globalPriorityQuery |= enabled->globalPriorityQuery == VK_TRUE;
                 features->shaderSubgroupRotate |= enabled->shaderSubgroupRotate == VK_TRUE;
                 features->shaderSubgroupRotateClustered |= enabled->shaderSubgroupRotateClustered == VK_TRUE;
@@ -477,69 +477,69 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: {
-                const VkPhysicalDeviceGlobalPriorityQueryFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures *>(pNext);
+                const VkPhysicalDeviceGlobalPriorityQueryFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures*>(pNext);
                 features->globalPriorityQuery |= enabled->globalPriorityQuery == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: {
-                const VkPhysicalDeviceIndexTypeUint8Features *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features *>(pNext);
+                const VkPhysicalDeviceIndexTypeUint8Features* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features*>(pNext);
                 features->indexTypeUint8 |= enabled->indexTypeUint8 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: {
-                const VkPhysicalDeviceMaintenance5Features *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance5Features *>(pNext);
+                const VkPhysicalDeviceMaintenance5Features* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance5Features*>(pNext);
                 features->maintenance5 |= enabled->maintenance5 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: {
-                const VkPhysicalDeviceMaintenance6Features *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance6Features *>(pNext);
+                const VkPhysicalDeviceMaintenance6Features* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance6Features*>(pNext);
                 features->maintenance6 |= enabled->maintenance6 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: {
-                const VkPhysicalDeviceHostImageCopyFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures *>(pNext);
+                const VkPhysicalDeviceHostImageCopyFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures*>(pNext);
                 features->hostImageCopy |= enabled->hostImageCopy == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: {
-                const VkPhysicalDeviceShaderSubgroupRotateFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures *>(pNext);
+                const VkPhysicalDeviceShaderSubgroupRotateFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures*>(pNext);
                 features->shaderSubgroupRotate |= enabled->shaderSubgroupRotate == VK_TRUE;
                 features->shaderSubgroupRotateClustered |= enabled->shaderSubgroupRotateClustered == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: {
-                const VkPhysicalDeviceShaderFloatControls2Features *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features *>(pNext);
+                const VkPhysicalDeviceShaderFloatControls2Features* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features*>(pNext);
                 features->shaderFloatControls2 |= enabled->shaderFloatControls2 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: {
-                const VkPhysicalDeviceShaderExpectAssumeFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures *>(pNext);
+                const VkPhysicalDeviceShaderExpectAssumeFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures*>(pNext);
                 features->shaderExpectAssume |= enabled->shaderExpectAssume == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: {
-                const VkPhysicalDevicePipelineProtectedAccessFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures *>(pNext);
+                const VkPhysicalDevicePipelineProtectedAccessFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures*>(pNext);
                 features->pipelineProtectedAccess |= enabled->pipelineProtectedAccess == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: {
-                const VkPhysicalDevicePipelineRobustnessFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures *>(pNext);
+                const VkPhysicalDevicePipelineRobustnessFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures*>(pNext);
                 features->pipelineRobustness |= enabled->pipelineRobustness == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: {
-                const VkPhysicalDeviceLineRasterizationFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures *>(pNext);
+                const VkPhysicalDeviceLineRasterizationFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures*>(pNext);
                 features->rectangularLines |= enabled->rectangularLines == VK_TRUE;
                 features->bresenhamLines |= enabled->bresenhamLines == VK_TRUE;
                 features->smoothLines |= enabled->smoothLines == VK_TRUE;
@@ -549,34 +549,34 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: {
-                const VkPhysicalDeviceVertexAttributeDivisorFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures *>(pNext);
+                const VkPhysicalDeviceVertexAttributeDivisorFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures*>(pNext);
                 features->vertexAttributeInstanceRateDivisor |= enabled->vertexAttributeInstanceRateDivisor == VK_TRUE;
                 features->vertexAttributeInstanceRateZeroDivisor |= enabled->vertexAttributeInstanceRateZeroDivisor == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: {
-                const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *>(pNext);
+                const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(pNext);
                 features->dynamicRenderingLocalRead |= enabled->dynamicRenderingLocalRead == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES: {
-                const VkPhysicalDeviceVulkanSC10Features *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVulkanSC10Features *>(pNext);
+                const VkPhysicalDeviceVulkanSC10Features* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVulkanSC10Features*>(pNext);
                 features->shaderAtomicInstructions |= enabled->shaderAtomicInstructions == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
-                const VkPhysicalDevicePerformanceQueryFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR *>(pNext);
+                const VkPhysicalDevicePerformanceQueryFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(pNext);
                 features->performanceCounterQueryPools |= enabled->performanceCounterQueryPools == VK_TRUE;
                 features->performanceCounterMultipleQueryPools |= enabled->performanceCounterMultipleQueryPools == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: {
-                const VkPhysicalDeviceShaderBfloat16FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceShaderBfloat16FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR*>(pNext);
                 features->shaderBFloat16Type |= enabled->shaderBFloat16Type == VK_TRUE;
                 features->shaderBFloat16DotProduct |= enabled->shaderBFloat16DotProduct == VK_TRUE;
                 features->shaderBFloat16CooperativeMatrix |= enabled->shaderBFloat16CooperativeMatrix == VK_TRUE;
@@ -584,8 +584,8 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
             }
 #ifdef VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
-                const VkPhysicalDevicePortabilitySubsetFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(pNext);
+                const VkPhysicalDevicePortabilitySubsetFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(pNext);
                 features->constantAlphaColorBlendFactors |= enabled->constantAlphaColorBlendFactors == VK_TRUE;
                 features->events |= enabled->events == VK_TRUE;
                 features->imageViewFormatReinterpretation |= enabled->imageViewFormatReinterpretation == VK_TRUE;
@@ -605,77 +605,77 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
             }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
-                const VkPhysicalDeviceShaderClockFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceShaderClockFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(pNext);
                 features->shaderSubgroupClock |= enabled->shaderSubgroupClock == VK_TRUE;
                 features->shaderDeviceClock |= enabled->shaderDeviceClock == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
-                const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(pNext);
                 features->pipelineFragmentShadingRate |= enabled->pipelineFragmentShadingRate == VK_TRUE;
                 features->primitiveFragmentShadingRate |= enabled->primitiveFragmentShadingRate == VK_TRUE;
                 features->attachmentFragmentShadingRate |= enabled->attachmentFragmentShadingRate == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR: {
-                const VkPhysicalDeviceShaderConstantDataFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderConstantDataFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceShaderConstantDataFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderConstantDataFeaturesKHR*>(pNext);
                 features->shaderConstantData |= enabled->shaderConstantData == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR: {
-                const VkPhysicalDeviceShaderAbortFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderAbortFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceShaderAbortFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderAbortFeaturesKHR*>(pNext);
                 features->shaderAbort |= enabled->shaderAbort == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: {
-                const VkPhysicalDeviceShaderQuadControlFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceShaderQuadControlFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR*>(pNext);
                 features->shaderQuadControl |= enabled->shaderQuadControl == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
-                const VkPhysicalDevicePresentWaitFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR *>(pNext);
+                const VkPhysicalDevicePresentWaitFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(pNext);
                 features->presentWait |= enabled->presentWait == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
-                const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(pNext);
+                const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(pNext);
                 features->pipelineExecutableInfo |= enabled->pipelineExecutableInfo == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
-                const VkPhysicalDevicePresentIdFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR *>(pNext);
+                const VkPhysicalDevicePresentIdFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(pNext);
                 features->presentId |= enabled->presentId == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR: {
-                const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR*>(pNext);
                 features->deviceAddressCommands |= enabled->deviceAddressCommands == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
-                const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(pNext);
                 features->fragmentShaderBarycentric |= enabled->fragmentShaderBarycentric == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
-                const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(pNext);
                 features->shaderSubgroupUniformControlFlow |= enabled->shaderSubgroupUniformControlFlow == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
-                const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(pNext);
                 features->workgroupMemoryExplicitLayout |= enabled->workgroupMemoryExplicitLayout == VK_TRUE;
                 features->workgroupMemoryExplicitLayoutScalarBlockLayout |=
                     enabled->workgroupMemoryExplicitLayoutScalarBlockLayout == VK_TRUE;
@@ -684,132 +684,132 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
-                const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(pNext);
                 features->rayTracingMaintenance1 |= enabled->rayTracingMaintenance1 == VK_TRUE;
                 features->rayTracingPipelineTraceRaysIndirect2 |= enabled->rayTracingPipelineTraceRaysIndirect2 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: {
-                const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR*>(pNext);
                 features->shaderUntypedPointers |= enabled->shaderUntypedPointers == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: {
-                const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*>(pNext);
                 features->shaderMaximalReconvergence |= enabled->shaderMaximalReconvergence == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: {
-                const VkPhysicalDevicePresentId2FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePresentId2FeaturesKHR *>(pNext);
+                const VkPhysicalDevicePresentId2FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePresentId2FeaturesKHR*>(pNext);
                 features->presentId2 |= enabled->presentId2 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: {
-                const VkPhysicalDevicePresentWait2FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePresentWait2FeaturesKHR *>(pNext);
+                const VkPhysicalDevicePresentWait2FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePresentWait2FeaturesKHR*>(pNext);
                 features->presentWait2 |= enabled->presentWait2 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
-                const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(pNext);
                 features->rayTracingPositionFetch |= enabled->rayTracingPositionFetch == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: {
-                const VkPhysicalDevicePipelineBinaryFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR *>(pNext);
+                const VkPhysicalDevicePipelineBinaryFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR*>(pNext);
                 features->pipelineBinaries |= enabled->pipelineBinaries == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: {
-                const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR*>(pNext);
                 features->swapchainMaintenance1 |= enabled->swapchainMaintenance1 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR: {
-                const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR*>(pNext);
                 features->internallySynchronizedQueues |= enabled->internallySynchronizedQueues == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: {
-                const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR*>(pNext);
                 features->cooperativeMatrix |= enabled->cooperativeMatrix == VK_TRUE;
                 features->cooperativeMatrixRobustBufferAccess |= enabled->cooperativeMatrixRobustBufferAccess == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: {
-                const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*>(pNext);
                 features->computeDerivativeGroupQuads |= enabled->computeDerivativeGroupQuads == VK_TRUE;
                 features->computeDerivativeGroupLinear |= enabled->computeDerivativeGroupLinear == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: {
-                const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*>(pNext);
                 features->videoEncodeAV1 |= enabled->videoEncodeAV1 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: {
-                const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*>(pNext);
                 features->videoDecodeVP9 |= enabled->videoDecodeVP9 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: {
-                const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR*>(pNext);
                 features->videoMaintenance1 |= enabled->videoMaintenance1 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: {
-                const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*>(pNext);
                 features->unifiedImageLayouts |= enabled->unifiedImageLayouts == VK_TRUE;
                 features->unifiedImageLayoutsVideo |= enabled->unifiedImageLayoutsVideo == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: {
-                const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR*>(pNext);
                 features->indirectMemoryCopy |= enabled->indirectMemoryCopy == VK_TRUE;
                 features->indirectMemoryToImageCopy |= enabled->indirectMemoryToImageCopy == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: {
-                const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR*>(pNext);
                 features->videoEncodeIntraRefresh |= enabled->videoEncodeIntraRefresh == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: {
-                const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*>(pNext);
                 features->videoEncodeQuantizationMap |= enabled->videoEncodeQuantizationMap == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: {
-                const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*>(pNext);
                 features->shaderRelaxedExtendedInstruction |= enabled->shaderRelaxedExtendedInstruction == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: {
-                const VkPhysicalDeviceMaintenance7FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance7FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceMaintenance7FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance7FeaturesKHR*>(pNext);
                 features->maintenance7 |= enabled->maintenance7 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR: {
-                const VkPhysicalDeviceFaultFeaturesKHR *enabled = reinterpret_cast<const VkPhysicalDeviceFaultFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceFaultFeaturesKHR* enabled = reinterpret_cast<const VkPhysicalDeviceFaultFeaturesKHR*>(pNext);
                 features->deviceFault |= enabled->deviceFault == VK_TRUE;
                 features->deviceFaultVendorBinary |= enabled->deviceFaultVendorBinary == VK_TRUE;
                 features->deviceFaultReportMasked |= enabled->deviceFaultReportMasked == VK_TRUE;
@@ -817,121 +817,121 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: {
-                const VkPhysicalDeviceMaintenance8FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance8FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceMaintenance8FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance8FeaturesKHR*>(pNext);
                 features->maintenance8 |= enabled->maintenance8 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR: {
-                const VkPhysicalDeviceShaderFmaFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceShaderFmaFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR*>(pNext);
                 features->shaderFmaFloat16 |= enabled->shaderFmaFloat16 == VK_TRUE;
                 features->shaderFmaFloat32 |= enabled->shaderFmaFloat32 == VK_TRUE;
                 features->shaderFmaFloat64 |= enabled->shaderFmaFloat64 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: {
-                const VkPhysicalDeviceMaintenance9FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance9FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceMaintenance9FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance9FeaturesKHR*>(pNext);
                 features->maintenance9 |= enabled->maintenance9 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: {
-                const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceVideoMaintenance2FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR*>(pNext);
                 features->videoMaintenance2 |= enabled->videoMaintenance2 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR: {
-                const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR*>(pNext);
                 features->videoEncodeFeedback2 |= enabled->videoEncodeFeedback2 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: {
-                const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*>(pNext);
                 features->depthClampZeroOne |= enabled->depthClampZeroOne == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: {
-                const VkPhysicalDeviceRobustness2FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceRobustness2FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR*>(pNext);
                 features->robustBufferAccess2 |= enabled->robustBufferAccess2 == VK_TRUE;
                 features->robustImageAccess2 |= enabled->robustImageAccess2 == VK_TRUE;
                 features->nullDescriptor |= enabled->nullDescriptor == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: {
-                const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *>(pNext);
+                const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*>(pNext);
                 features->presentModeFifoLatestReady |= enabled->presentModeFifoLatestReady == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR: {
-                const VkPhysicalDeviceOpacityMicromapFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceOpacityMicromapFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesKHR*>(pNext);
                 features->micromap |= enabled->micromap == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: {
-                const VkPhysicalDeviceMaintenance10FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance10FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceMaintenance10FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance10FeaturesKHR*>(pNext);
                 features->maintenance10 |= enabled->maintenance10 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR: {
-                const VkPhysicalDeviceMaintenance11FeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance11FeaturesKHR *>(pNext);
+                const VkPhysicalDeviceMaintenance11FeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance11FeaturesKHR*>(pNext);
                 features->maintenance11 |= enabled->maintenance11 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR: {
-                const VkPhysicalDeviceExtendedFlagsFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceExtendedFlagsFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceExtendedFlagsFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceExtendedFlagsFeaturesKHR*>(pNext);
                 features->extendedFlags |= enabled->extendedFlags == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
-                const VkPhysicalDeviceTransformFeedbackFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceTransformFeedbackFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(pNext);
                 features->transformFeedback |= enabled->transformFeedback == VK_TRUE;
                 features->geometryStreams |= enabled->geometryStreams == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
-                const VkPhysicalDeviceCornerSampledImageFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV *>(pNext);
+                const VkPhysicalDeviceCornerSampledImageFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(pNext);
                 features->cornerSampledImage |= enabled->cornerSampledImage == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
-                const VkPhysicalDeviceASTCDecodeFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceASTCDecodeFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(pNext);
                 features->decodeModeSharedExponent |= enabled->decodeModeSharedExponent == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
-                const VkPhysicalDeviceConditionalRenderingFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceConditionalRenderingFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(pNext);
                 features->conditionalRendering |= enabled->conditionalRendering == VK_TRUE;
                 features->inheritedConditionalRendering |= enabled->inheritedConditionalRendering == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
-                const VkPhysicalDeviceDepthClipEnableFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceDepthClipEnableFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(pNext);
                 features->depthClipEnable |= enabled->depthClipEnable == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: {
-                const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *>(pNext);
+                const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(pNext);
                 features->relaxedLineRasterization |= enabled->relaxedLineRasterization == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD: {
-                const VkPhysicalDeviceGpaFeaturesAMD *enabled = reinterpret_cast<const VkPhysicalDeviceGpaFeaturesAMD *>(pNext);
+                const VkPhysicalDeviceGpaFeaturesAMD* enabled = reinterpret_cast<const VkPhysicalDeviceGpaFeaturesAMD*>(pNext);
                 features->perfCounters |= enabled->perfCounters == VK_TRUE;
                 features->streamingPerfCounters |= enabled->streamingPerfCounters == VK_TRUE;
                 features->sqThreadTracing |= enabled->sqThreadTracing == VK_TRUE;
@@ -940,169 +940,169 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
             }
 #ifdef VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: {
-                const VkPhysicalDeviceShaderEnqueueFeaturesAMDX *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX *>(pNext);
+                const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX*>(pNext);
                 features->shaderEnqueue |= enabled->shaderEnqueue == VK_TRUE;
                 features->shaderMeshEnqueue |= enabled->shaderMeshEnqueue == VK_TRUE;
                 break;
             }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT: {
-                const VkPhysicalDeviceDescriptorHeapFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDescriptorHeapFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceDescriptorHeapFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDescriptorHeapFeaturesEXT*>(pNext);
                 features->descriptorHeap |= enabled->descriptorHeap == VK_TRUE;
                 features->descriptorHeapCaptureReplay |= enabled->descriptorHeapCaptureReplay == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
-                const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(pNext);
                 features->advancedBlendCoherentOperations |= enabled->advancedBlendCoherentOperations == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
-                const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(pNext);
+                const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(pNext);
                 features->shaderSMBuiltins |= enabled->shaderSMBuiltins == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
-                const VkPhysicalDeviceShadingRateImageFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV *>(pNext);
+                const VkPhysicalDeviceShadingRateImageFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(pNext);
                 features->shadingRateImage |= enabled->shadingRateImage == VK_TRUE;
                 features->shadingRateCoarseSampleOrder |= enabled->shadingRateCoarseSampleOrder == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
-                const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(pNext);
+                const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(pNext);
                 features->representativeFragmentTest |= enabled->representativeFragmentTest == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: {
-                const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*>(pNext);
                 features->cooperativeMatrixConversion |= enabled->cooperativeMatrixConversion == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM: {
-                const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM*>(pNext);
                 features->elapsedTimerQuery |= enabled->elapsedTimerQuery == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
-                const VkPhysicalDeviceMeshShaderFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV *>(pNext);
+                const VkPhysicalDeviceMeshShaderFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(pNext);
                 features->taskShader |= enabled->taskShader == VK_TRUE;
                 features->meshShader |= enabled->meshShader == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
-                const VkPhysicalDeviceShaderImageFootprintFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(pNext);
+                const VkPhysicalDeviceShaderImageFootprintFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(pNext);
                 features->imageFootprint |= enabled->imageFootprint == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
-                const VkPhysicalDeviceExclusiveScissorFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV *>(pNext);
+                const VkPhysicalDeviceExclusiveScissorFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(pNext);
                 features->exclusiveScissor |= enabled->exclusiveScissor == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: {
-                const VkPhysicalDevicePresentTimingFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePresentTimingFeaturesEXT *>(pNext);
+                const VkPhysicalDevicePresentTimingFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePresentTimingFeaturesEXT*>(pNext);
                 features->presentTiming |= enabled->presentTiming == VK_TRUE;
                 features->presentAtAbsoluteTime |= enabled->presentAtAbsoluteTime == VK_TRUE;
                 features->presentAtRelativeTime |= enabled->presentAtRelativeTime == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
-                const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(pNext);
+                const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(pNext);
                 features->shaderIntegerFunctions2 |= enabled->shaderIntegerFunctions2 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
-                const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(pNext);
                 features->fragmentDensityMap |= enabled->fragmentDensityMap == VK_TRUE;
                 features->fragmentDensityMapDynamic |= enabled->fragmentDensityMapDynamic == VK_TRUE;
                 features->fragmentDensityMapNonSubsampledImages |= enabled->fragmentDensityMapNonSubsampledImages == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
-                const VkPhysicalDeviceCoherentMemoryFeaturesAMD *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(pNext);
+                const VkPhysicalDeviceCoherentMemoryFeaturesAMD* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(pNext);
                 features->deviceCoherentMemory |= enabled->deviceCoherentMemory == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
-                const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(pNext);
                 features->shaderImageInt64Atomics |= enabled->shaderImageInt64Atomics == VK_TRUE;
                 features->sparseImageInt64Atomics |= enabled->sparseImageInt64Atomics == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
-                const VkPhysicalDeviceMemoryPriorityFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceMemoryPriorityFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(pNext);
                 features->memoryPriority |= enabled->memoryPriority == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
-                const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(pNext);
+                const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(pNext);
                 features->dedicatedAllocationImageAliasing |= enabled->dedicatedAllocationImageAliasing == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
-                const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(pNext);
                 features->bufferDeviceAddressEXT |= enabled->bufferDeviceAddress == VK_TRUE;
                 features->bufferDeviceAddressCaptureReplayEXT |= enabled->bufferDeviceAddressCaptureReplay == VK_TRUE;
                 features->bufferDeviceAddressMultiDeviceEXT |= enabled->bufferDeviceAddressMultiDevice == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
-                const VkPhysicalDeviceCooperativeMatrixFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(pNext);
+                const VkPhysicalDeviceCooperativeMatrixFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(pNext);
                 features->cooperativeMatrix |= enabled->cooperativeMatrix == VK_TRUE;
                 features->cooperativeMatrixRobustBufferAccess |= enabled->cooperativeMatrixRobustBufferAccess == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
-                const VkPhysicalDeviceCoverageReductionModeFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(pNext);
+                const VkPhysicalDeviceCoverageReductionModeFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(pNext);
                 features->coverageReductionMode |= enabled->coverageReductionMode == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
-                const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(pNext);
                 features->fragmentShaderSampleInterlock |= enabled->fragmentShaderSampleInterlock == VK_TRUE;
                 features->fragmentShaderPixelInterlock |= enabled->fragmentShaderPixelInterlock == VK_TRUE;
                 features->fragmentShaderShadingRateInterlock |= enabled->fragmentShaderShadingRateInterlock == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
-                const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(pNext);
                 features->ycbcrImageArrays |= enabled->ycbcrImageArrays == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
-                const VkPhysicalDeviceProvokingVertexFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceProvokingVertexFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(pNext);
                 features->provokingVertexLast |= enabled->provokingVertexLast == VK_TRUE;
                 features->transformFeedbackPreservesProvokingVertex |=
                     enabled->transformFeedbackPreservesProvokingVertex == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
-                const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(pNext);
                 features->shaderBufferFloat32Atomics |= enabled->shaderBufferFloat32Atomics == VK_TRUE;
                 features->shaderBufferFloat32AtomicAdd |= enabled->shaderBufferFloat32AtomicAdd == VK_TRUE;
                 features->shaderBufferFloat64Atomics |= enabled->shaderBufferFloat64Atomics == VK_TRUE;
@@ -1118,22 +1118,22 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
-                const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(pNext);
                 features->extendedDynamicState |= enabled->extendedDynamicState == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: {
-                const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(pNext);
                 features->memoryMapPlaced |= enabled->memoryMapPlaced == VK_TRUE;
                 features->memoryMapRangePlaced |= enabled->memoryMapRangePlaced == VK_TRUE;
                 features->memoryUnmapReserve |= enabled->memoryUnmapReserve == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
-                const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(pNext);
                 features->shaderBufferFloat16Atomics |= enabled->shaderBufferFloat16Atomics == VK_TRUE;
                 features->shaderBufferFloat16AtomicAdd |= enabled->shaderBufferFloat16AtomicAdd == VK_TRUE;
                 features->shaderBufferFloat16AtomicMinMax |= enabled->shaderBufferFloat16AtomicMinMax == VK_TRUE;
@@ -1149,26 +1149,26 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
-                const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>(pNext);
+                const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(pNext);
                 features->deviceGeneratedCommandsNV |= enabled->deviceGeneratedCommands == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
-                const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>(pNext);
+                const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(pNext);
                 features->inheritedViewportScissor2D |= enabled->inheritedViewportScissor2D == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
-                const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(pNext);
                 features->texelBufferAlignment |= enabled->texelBufferAlignment == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: {
-                const VkPhysicalDeviceDepthBiasControlFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceDepthBiasControlFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(pNext);
                 features->depthBiasControl |= enabled->depthBiasControl == VK_TRUE;
                 features->leastRepresentableValueForceUnormRepresentation |=
                     enabled->leastRepresentableValueForceUnormRepresentation == VK_TRUE;
@@ -1177,73 +1177,73 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
-                const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(pNext);
                 features->deviceMemoryReport |= enabled->deviceMemoryReport == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
-                const VkPhysicalDeviceCustomBorderColorFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceCustomBorderColorFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(pNext);
                 features->customBorderColors |= enabled->customBorderColors == VK_TRUE;
                 features->customBorderColorWithoutFormat |= enabled->customBorderColorWithoutFormat == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT: {
-                const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT*>(pNext);
                 features->textureCompressionASTC_3D |= enabled->textureCompressionASTC_3D == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
-                const VkPhysicalDevicePresentBarrierFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV *>(pNext);
+                const VkPhysicalDevicePresentBarrierFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(pNext);
                 features->presentBarrier |= enabled->presentBarrier == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
-                const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>(pNext);
+                const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(pNext);
                 features->diagnosticsConfig |= enabled->diagnosticsConfig == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM: {
-                const VkPhysicalDeviceQueuePerfHintFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceQueuePerfHintFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceQueuePerfHintFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceQueuePerfHintFeaturesQCOM*>(pNext);
                 features->queuePerfHint |= enabled->queuePerfHint == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM: {
-                const VkPhysicalDeviceImageProcessing3FeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceImageProcessing3FeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceImageProcessing3FeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceImageProcessing3FeaturesQCOM*>(pNext);
                 features->imageGatherLinear |= enabled->imageGatherLinear == VK_TRUE;
                 features->imageGatherExtendedModes |= enabled->imageGatherExtendedModes == VK_TRUE;
                 features->blockMatchExtendedClampToEdge |= enabled->blockMatchExtendedClampToEdge == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM: {
-                const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM*>(pNext);
                 features->shaderMultipleWaitQueues |= enabled->shaderMultipleWaitQueues == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT: {
-                const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT*>(pNext);
                 features->shaderSplitBarrier |= enabled->shaderSplitBarrier == VK_TRUE;
                 break;
             }
 #ifdef VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: {
-                const VkPhysicalDeviceCudaKernelLaunchFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV *>(pNext);
+                const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV*>(pNext);
                 features->cudaKernelLaunchFeatures |= enabled->cudaKernelLaunchFeatures == VK_TRUE;
                 break;
             }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: {
-                const VkPhysicalDeviceTileShadingFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceTileShadingFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM*>(pNext);
                 features->tileShading |= enabled->tileShading == VK_TRUE;
                 features->tileShadingFragmentStage |= enabled->tileShadingFragmentStage == VK_TRUE;
                 features->tileShadingColorAttachments |= enabled->tileShadingColorAttachments == VK_TRUE;
@@ -1261,8 +1261,8 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
-                const VkPhysicalDeviceDescriptorBufferFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceDescriptorBufferFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(pNext);
                 features->descriptorBuffer |= enabled->descriptorBuffer == VK_TRUE;
                 features->descriptorBufferCaptureReplay |= enabled->descriptorBufferCaptureReplay == VK_TRUE;
                 features->descriptorBufferImageLayoutIgnored |= enabled->descriptorBufferImageLayoutIgnored == VK_TRUE;
@@ -1270,73 +1270,73 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
-                const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(pNext);
                 features->graphicsPipelineLibrary |= enabled->graphicsPipelineLibrary == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
-                const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *>(pNext);
+                const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(pNext);
                 features->shaderEarlyAndLateFragmentTests |= enabled->shaderEarlyAndLateFragmentTests == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
-                const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(pNext);
+                const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(pNext);
                 features->fragmentShadingRateEnums |= enabled->fragmentShadingRateEnums == VK_TRUE;
                 features->supersampleFragmentShadingRates |= enabled->supersampleFragmentShadingRates == VK_TRUE;
                 features->noInvocationFragmentShadingRates |= enabled->noInvocationFragmentShadingRates == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
-                const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>(pNext);
+                const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(pNext);
                 features->rayTracingMotionBlur |= enabled->rayTracingMotionBlur == VK_TRUE;
                 features->rayTracingMotionBlurPipelineTraceRaysIndirect |=
                     enabled->rayTracingMotionBlurPipelineTraceRaysIndirect == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
-                const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(pNext);
                 features->ycbcr2plane444Formats |= enabled->ycbcr2plane444Formats == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
-                const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>(pNext);
+                const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(pNext);
                 features->fragmentDensityMapDeferred |= enabled->fragmentDensityMapDeferred == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
-                const VkPhysicalDeviceImageCompressionControlFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceImageCompressionControlFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(pNext);
                 features->imageCompressionControl |= enabled->imageCompressionControl == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
-                const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(pNext);
                 features->attachmentFeedbackLoopLayout |= enabled->attachmentFeedbackLoopLayout == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
-                const VkPhysicalDevice4444FormatsFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT *>(pNext);
+                const VkPhysicalDevice4444FormatsFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(pNext);
                 features->formatA4R4G4B4 |= enabled->formatA4R4G4B4 == VK_TRUE;
                 features->formatA4B4G4R4 |= enabled->formatA4B4G4R4 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
-                const VkPhysicalDeviceFaultFeaturesEXT *enabled = reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceFaultFeaturesEXT* enabled = reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(pNext);
                 features->deviceFault |= enabled->deviceFault == VK_TRUE;
                 features->deviceFaultVendorBinary |= enabled->deviceFaultVendorBinary == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
-                const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(pNext);
                 features->rasterizationOrderColorAttachmentAccess |= enabled->rasterizationOrderColorAttachmentAccess == VK_TRUE;
                 features->rasterizationOrderDepthAttachmentAccess |= enabled->rasterizationOrderDepthAttachmentAccess == VK_TRUE;
                 features->rasterizationOrderStencilAttachmentAccess |=
@@ -1344,70 +1344,70 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
-                const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(pNext);
                 features->formatRgba10x6WithoutYCbCrSampler |= enabled->formatRgba10x6WithoutYCbCrSampler == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
-                const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(pNext);
                 features->mutableDescriptorType |= enabled->mutableDescriptorType == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
-                const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(pNext);
                 features->vertexInputDynamicState |= enabled->vertexInputDynamicState == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
-                const VkPhysicalDeviceAddressBindingReportFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceAddressBindingReportFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(pNext);
                 features->reportAddressBinding |= enabled->reportAddressBinding == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
-                const VkPhysicalDeviceDepthClipControlFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceDepthClipControlFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(pNext);
                 features->depthClipControl |= enabled->depthClipControl == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
-                const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(pNext);
+                const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(pNext);
                 features->primitiveTopologyListRestart |= enabled->primitiveTopologyListRestart == VK_TRUE;
                 features->primitiveTopologyPatchListRestart |= enabled->primitiveTopologyPatchListRestart == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
-                const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>(pNext);
+                const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(pNext);
                 features->subpassShading |= enabled->subpassShading == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
-                const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>(pNext);
+                const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(pNext);
                 features->invocationMask |= enabled->invocationMask == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
-                const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>(pNext);
+                const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(pNext);
                 features->externalMemoryRDMA |= enabled->externalMemoryRDMA == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
-                const VkPhysicalDevicePipelinePropertiesFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT *>(pNext);
+                const VkPhysicalDevicePipelinePropertiesFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(pNext);
                 features->pipelinePropertiesIdentifier |= enabled->pipelinePropertiesIdentifier == VK_TRUE;
                 break;
             }
 #ifdef VK_USE_PLATFORM_SCI
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV: {
-                const VkPhysicalDeviceExternalSciSyncFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceExternalSciSyncFeaturesNV *>(pNext);
+                const VkPhysicalDeviceExternalSciSyncFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceExternalSciSyncFeaturesNV*>(pNext);
                 features->sciSyncFence |= enabled->sciSyncFence == VK_TRUE;
                 features->sciSyncSemaphore |= enabled->sciSyncSemaphore == VK_TRUE;
                 features->sciSyncImport |= enabled->sciSyncImport == VK_TRUE;
@@ -1417,42 +1417,42 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
 #endif  // VK_USE_PLATFORM_SCI
 #ifdef VK_USE_PLATFORM_SCI
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV: {
-                const VkPhysicalDeviceExternalMemorySciBufFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceExternalMemorySciBufFeaturesNV *>(pNext);
+                const VkPhysicalDeviceExternalMemorySciBufFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceExternalMemorySciBufFeaturesNV*>(pNext);
                 features->sciBufImport |= enabled->sciBufImport == VK_TRUE;
                 features->sciBufExport |= enabled->sciBufExport == VK_TRUE;
                 break;
             }
 #endif  // VK_USE_PLATFORM_SCI
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: {
-                const VkPhysicalDeviceFrameBoundaryFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceFrameBoundaryFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT*>(pNext);
                 features->frameBoundary |= enabled->frameBoundary == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
-                const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(pNext);
                 features->multisampledRenderToSingleSampled |= enabled->multisampledRenderToSingleSampled == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
-                const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>(pNext);
+                const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(pNext);
                 features->extendedDynamicState2 |= enabled->extendedDynamicState2 == VK_TRUE;
                 features->extendedDynamicState2LogicOp |= enabled->extendedDynamicState2LogicOp == VK_TRUE;
                 features->extendedDynamicState2PatchControlPoints |= enabled->extendedDynamicState2PatchControlPoints == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
-                const VkPhysicalDeviceColorWriteEnableFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceColorWriteEnableFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(pNext);
                 features->colorWriteEnable |= enabled->colorWriteEnable == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
-                const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(pNext);
+                const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(pNext);
                 features->primitivesGeneratedQuery |= enabled->primitivesGeneratedQuery == VK_TRUE;
                 features->primitivesGeneratedQueryWithRasterizerDiscard |=
                     enabled->primitivesGeneratedQueryWithRasterizerDiscard == VK_TRUE;
@@ -1461,41 +1461,41 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: {
-                const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *>(pNext);
+                const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE*>(pNext);
                 features->videoEncodeRgbConversion |= enabled->videoEncodeRgbConversion == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
-                const VkPhysicalDeviceImageViewMinLodFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceImageViewMinLodFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(pNext);
                 features->minLod |= enabled->minLod == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
-                const VkPhysicalDeviceMultiDrawFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceMultiDrawFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(pNext);
                 features->multiDraw |= enabled->multiDraw == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
-                const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(pNext);
                 features->image2DViewOf3D |= enabled->image2DViewOf3D == VK_TRUE;
                 features->sampler2DViewOf3D |= enabled->sampler2DViewOf3D == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
-                const VkPhysicalDeviceShaderTileImageFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShaderTileImageFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(pNext);
                 features->shaderTileImageColorReadAccess |= enabled->shaderTileImageColorReadAccess == VK_TRUE;
                 features->shaderTileImageDepthReadAccess |= enabled->shaderTileImageDepthReadAccess == VK_TRUE;
                 features->shaderTileImageStencilReadAccess |= enabled->shaderTileImageStencilReadAccess == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
-                const VkPhysicalDeviceOpacityMicromapFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceOpacityMicromapFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(pNext);
                 features->micromapEXT |= enabled->micromap == VK_TRUE;
                 features->micromapCaptureReplayEXT |= enabled->micromapCaptureReplay == VK_TRUE;
                 features->micromapHostCommandsEXT |= enabled->micromapHostCommands == VK_TRUE;
@@ -1503,132 +1503,132 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
             }
 #ifdef VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
-                const VkPhysicalDeviceDisplacementMicromapFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV *>(pNext);
+                const VkPhysicalDeviceDisplacementMicromapFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(pNext);
                 features->displacementMicromap |= enabled->displacementMicromap == VK_TRUE;
                 break;
             }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
-                const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *>(pNext);
+                const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(pNext);
                 features->clustercullingShader |= enabled->clustercullingShader == VK_TRUE;
                 features->multiviewClusterCullingShader |= enabled->multiviewClusterCullingShader == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: {
-                const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI *>(pNext);
+                const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI*>(pNext);
                 features->clusterShadingRate |= enabled->clusterShadingRate == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
-                const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(pNext);
                 features->borderColorSwizzle |= enabled->borderColorSwizzle == VK_TRUE;
                 features->borderColorSwizzleFromImage |= enabled->borderColorSwizzleFromImage == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
-                const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>(pNext);
+                const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(pNext);
                 features->pageableDeviceLocalMemory |= enabled->pageableDeviceLocalMemory == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: {
-                const VkPhysicalDeviceSchedulingControlsFeaturesARM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM *>(pNext);
+                const VkPhysicalDeviceSchedulingControlsFeaturesARM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM*>(pNext);
                 features->schedulingControls |= enabled->schedulingControls == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
-                const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(pNext);
                 features->imageSlicedViewOf3D |= enabled->imageSlicedViewOf3D == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
-                const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *>(pNext);
+                const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(pNext);
                 features->descriptorSetHostMapping |= enabled->descriptorSetHostMapping == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
-                const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(pNext);
                 features->nonSeamlessCubeMap |= enabled->nonSeamlessCubeMap == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: {
-                const VkPhysicalDeviceRenderPassStripedFeaturesARM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM *>(pNext);
+                const VkPhysicalDeviceRenderPassStripedFeaturesARM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM*>(pNext);
                 features->renderPassStriped |= enabled->renderPassStriped == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: {
-                const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*>(pNext);
                 features->fragmentDensityMapOffset |= enabled->fragmentDensityMapOffset == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
-                const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *>(pNext);
+                const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(pNext);
                 features->indirectCopy |= enabled->indirectCopy == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT: {
-                const VkPhysicalDeviceMemoryDecompressionFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceMemoryDecompressionFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesEXT*>(pNext);
                 features->memoryDecompression |= enabled->memoryDecompression == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: {
-                const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *>(pNext);
+                const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(pNext);
                 features->deviceGeneratedCompute |= enabled->deviceGeneratedCompute == VK_TRUE;
                 features->deviceGeneratedComputePipelines |= enabled->deviceGeneratedComputePipelines == VK_TRUE;
                 features->deviceGeneratedComputeCaptureReplay |= enabled->deviceGeneratedComputeCaptureReplay == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: {
-                const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *>(pNext);
+                const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*>(pNext);
                 features->spheres |= enabled->spheres == VK_TRUE;
                 features->linearSweptSpheres |= enabled->linearSweptSpheres == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
-                const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(pNext);
+                const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(pNext);
                 features->linearColorAttachment |= enabled->linearColorAttachment == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
-                const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(pNext);
                 features->imageCompressionControlSwapchain |= enabled->imageCompressionControlSwapchain == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
-                const VkPhysicalDeviceImageProcessingFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceImageProcessingFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(pNext);
                 features->textureSampleWeighted |= enabled->textureSampleWeighted == VK_TRUE;
                 features->textureBoxFilter |= enabled->textureBoxFilter == VK_TRUE;
                 features->textureBlockMatch |= enabled->textureBlockMatch == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: {
-                const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(pNext);
                 features->nestedCommandBuffer |= enabled->nestedCommandBuffer == VK_TRUE;
                 features->nestedCommandBufferRendering |= enabled->nestedCommandBufferRendering == VK_TRUE;
                 features->nestedCommandBufferSimultaneousUse |= enabled->nestedCommandBufferSimultaneousUse == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
-                const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(pNext);
+                const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(pNext);
                 features->extendedDynamicState3TessellationDomainOrigin |=
                     enabled->extendedDynamicState3TessellationDomainOrigin == VK_TRUE;
                 features->extendedDynamicState3DepthClampEnable |= enabled->extendedDynamicState3DepthClampEnable == VK_TRUE;
@@ -1680,14 +1680,14 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
-                const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(pNext);
                 features->subpassMergeFeedback |= enabled->subpassMergeFeedback == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: {
-                const VkPhysicalDeviceTensorFeaturesARM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceTensorFeaturesARM *>(pNext);
+                const VkPhysicalDeviceTensorFeaturesARM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceTensorFeaturesARM*>(pNext);
                 features->tensorNonPacked |= enabled->tensorNonPacked == VK_TRUE;
                 features->shaderTensorAccess |= enabled->shaderTensorAccess == VK_TRUE;
                 features->shaderStorageTensorArrayDynamicIndexing |= enabled->shaderStorageTensorArrayDynamicIndexing == VK_TRUE;
@@ -1699,79 +1699,79 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: {
-                const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *>(pNext);
+                const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM*>(pNext);
                 features->descriptorBufferTensorDescriptors |= enabled->descriptorBufferTensorDescriptors == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
-                const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(pNext);
                 features->shaderModuleIdentifier |= enabled->shaderModuleIdentifier == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
-                const VkPhysicalDeviceOpticalFlowFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV *>(pNext);
+                const VkPhysicalDeviceOpticalFlowFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(pNext);
                 features->opticalFlow |= enabled->opticalFlow == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
-                const VkPhysicalDeviceLegacyDitheringFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceLegacyDitheringFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(pNext);
                 features->legacyDithering |= enabled->legacyDithering == VK_TRUE;
                 break;
             }
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: {
-                const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *>(pNext);
+                const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*>(pNext);
                 features->externalFormatResolve |= enabled->externalFormatResolve == VK_TRUE;
                 break;
             }
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: {
-                const VkPhysicalDeviceAntiLagFeaturesAMD *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD *>(pNext);
+                const VkPhysicalDeviceAntiLagFeaturesAMD* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD*>(pNext);
                 features->antiLag |= enabled->antiLag == VK_TRUE;
                 break;
             }
 #ifdef VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: {
-                const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX *>(pNext);
+                const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX*>(pNext);
                 features->denseGeometryFormat |= enabled->denseGeometryFormat == VK_TRUE;
                 break;
             }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
-                const VkPhysicalDeviceShaderObjectFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShaderObjectFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(pNext);
                 features->shaderObject |= enabled->shaderObject == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
-                const VkPhysicalDeviceTilePropertiesFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceTilePropertiesFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(pNext);
                 features->tileProperties |= enabled->tileProperties == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
-                const VkPhysicalDeviceAmigoProfilingFeaturesSEC *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC *>(pNext);
+                const VkPhysicalDeviceAmigoProfilingFeaturesSEC* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(pNext);
                 features->amigoProfiling |= enabled->amigoProfiling == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
-                const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(pNext);
                 features->multiviewPerViewViewports |= enabled->multiviewPerViewViewports == VK_TRUE;
                 break;
             }
 #ifdef VK_USE_PLATFORM_SCI
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV: {
-                const VkPhysicalDeviceExternalSciSync2FeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceExternalSciSync2FeaturesNV *>(pNext);
+                const VkPhysicalDeviceExternalSciSync2FeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceExternalSciSync2FeaturesNV*>(pNext);
                 features->sciSyncFence |= enabled->sciSyncFence == VK_TRUE;
                 features->sciSyncSemaphore2 |= enabled->sciSyncSemaphore2 == VK_TRUE;
                 features->sciSyncImport |= enabled->sciSyncImport == VK_TRUE;
@@ -1780,51 +1780,51 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
             }
 #endif  // VK_USE_PLATFORM_SCI
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
-                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *>(pNext);
+                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(pNext);
                 features->rayTracingInvocationReorder |= enabled->rayTracingInvocationReorder == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: {
-                const VkPhysicalDeviceCooperativeVectorFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV *>(pNext);
+                const VkPhysicalDeviceCooperativeVectorFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV*>(pNext);
                 features->cooperativeVector |= enabled->cooperativeVector == VK_TRUE;
                 features->cooperativeVectorTraining |= enabled->cooperativeVectorTraining == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: {
-                const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(pNext);
+                const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*>(pNext);
                 features->extendedSparseAddressSpace |= enabled->extendedSparseAddressSpace == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: {
-                const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*>(pNext);
                 features->legacyVertexAttributes |= enabled->legacyVertexAttributes == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
-                const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *>(pNext);
+                const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(pNext);
                 features->shaderCoreBuiltins |= enabled->shaderCoreBuiltins == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
-                const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *>(pNext);
+                const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(pNext);
                 features->pipelineLibraryGroupHandles |= enabled->pipelineLibraryGroupHandles == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: {
-                const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*>(pNext);
                 features->dynamicRenderingUnusedAttachments |= enabled->dynamicRenderingUnusedAttachments == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: {
-                const VkPhysicalDeviceDataGraphFeaturesARM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDataGraphFeaturesARM *>(pNext);
+                const VkPhysicalDeviceDataGraphFeaturesARM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDataGraphFeaturesARM*>(pNext);
                 features->dataGraph |= enabled->dataGraph == VK_TRUE;
                 features->dataGraphUpdateAfterBind |= enabled->dataGraphUpdateAfterBind == VK_TRUE;
                 features->dataGraphSpecializationConstants |= enabled->dataGraphSpecializationConstants == VK_TRUE;
@@ -1833,157 +1833,157 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
-                const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(pNext);
                 features->multiviewPerViewRenderAreas |= enabled->multiviewPerViewRenderAreas == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: {
-                const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *>(pNext);
+                const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV*>(pNext);
                 features->perStageDescriptorSet |= enabled->perStageDescriptorSet == VK_TRUE;
                 features->dynamicPipelineLayout |= enabled->dynamicPipelineLayout == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: {
-                const VkPhysicalDeviceImageProcessing2FeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceImageProcessing2FeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM*>(pNext);
                 features->textureBlockMatch2 |= enabled->textureBlockMatch2 == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: {
-                const VkPhysicalDeviceCubicWeightsFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceCubicWeightsFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM*>(pNext);
                 features->selectableCubicWeights |= enabled->selectableCubicWeights == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: {
-                const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*>(pNext);
                 features->ycbcrDegamma |= enabled->ycbcrDegamma == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: {
-                const VkPhysicalDeviceCubicClampFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCubicClampFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceCubicClampFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCubicClampFeaturesQCOM*>(pNext);
                 features->cubicRangeClamp |= enabled->cubicRangeClamp == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
-                const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(pNext);
                 features->attachmentFeedbackLoopDynamicState |= enabled->attachmentFeedbackLoopDynamicState == VK_TRUE;
                 break;
             }
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: {
-                const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX *>(pNext);
+                const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*>(pNext);
                 features->screenBufferImport |= enabled->screenBufferImport == VK_TRUE;
                 break;
             }
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: {
-                const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(pNext);
+                const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*>(pNext);
                 features->descriptorPoolOverallocation |= enabled->descriptorPoolOverallocation == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: {
-                const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*>(pNext);
                 features->tileMemoryHeap |= enabled->tileMemoryHeap == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: {
-                const VkPhysicalDeviceRawAccessChainsFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV *>(pNext);
+                const VkPhysicalDeviceRawAccessChainsFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV*>(pNext);
                 features->shaderRawAccessChains |= enabled->shaderRawAccessChains == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: {
-                const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *>(pNext);
+                const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV*>(pNext);
                 features->commandBufferInheritance |= enabled->commandBufferInheritance == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: {
-                const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(pNext);
+                const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*>(pNext);
                 features->shaderFloat16VectorAtomics |= enabled->shaderFloat16VectorAtomics == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: {
-                const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*>(pNext);
                 features->shaderReplicatedComposites |= enabled->shaderReplicatedComposites == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: {
-                const VkPhysicalDeviceShaderFloat8FeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderFloat8FeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShaderFloat8FeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderFloat8FeaturesEXT*>(pNext);
                 features->shaderFloat8 |= enabled->shaderFloat8 == VK_TRUE;
                 features->shaderFloat8CooperativeMatrix |= enabled->shaderFloat8CooperativeMatrix == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: {
-                const VkPhysicalDeviceRayTracingValidationFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>(pNext);
+                const VkPhysicalDeviceRayTracingValidationFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV*>(pNext);
                 features->rayTracingValidation |= enabled->rayTracingValidation == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: {
-                const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *>(pNext);
+                const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*>(pNext);
                 features->clusterAccelerationStructure |= enabled->clusterAccelerationStructure == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: {
-                const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *>(pNext);
+                const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*>(pNext);
                 features->partitionedAccelerationStructure |= enabled->partitionedAccelerationStructure == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: {
-                const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*>(pNext);
                 features->deviceGeneratedCommands |= enabled->deviceGeneratedCommands == VK_TRUE;
                 features->dynamicGeneratedPipelineLayout |= enabled->dynamicGeneratedPipelineLayout == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: {
-                const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *>(pNext);
+                const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA*>(pNext);
                 features->imageAlignmentControl |= enabled->imageAlignmentControl == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV: {
-                const VkPhysicalDevicePushConstantBankFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePushConstantBankFeaturesNV *>(pNext);
+                const VkPhysicalDevicePushConstantBankFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePushConstantBankFeaturesNV*>(pNext);
                 features->pushConstantBank |= enabled->pushConstantBank == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT: {
-                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT*>(pNext);
                 features->rayTracingInvocationReorder |= enabled->rayTracingInvocationReorder == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: {
-                const VkPhysicalDeviceDepthClampControlFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDepthClampControlFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceDepthClampControlFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDepthClampControlFeaturesEXT*>(pNext);
                 features->depthClampControl |= enabled->depthClampControl == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: {
-                const VkPhysicalDeviceHdrVividFeaturesHUAWEI *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceHdrVividFeaturesHUAWEI *>(pNext);
+                const VkPhysicalDeviceHdrVividFeaturesHUAWEI* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceHdrVividFeaturesHUAWEI*>(pNext);
                 features->hdrVivid |= enabled->hdrVivid == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: {
-                const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(pNext);
+                const VkPhysicalDeviceCooperativeMatrix2FeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(pNext);
                 features->cooperativeMatrixWorkgroupScope |= enabled->cooperativeMatrixWorkgroupScope == VK_TRUE;
                 features->cooperativeMatrixFlexibleDimensions |= enabled->cooperativeMatrixFlexibleDimensions == VK_TRUE;
                 features->cooperativeMatrixReductions |= enabled->cooperativeMatrixReductions == VK_TRUE;
@@ -1994,116 +1994,116 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: {
-                const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *>(pNext);
+                const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM*>(pNext);
                 features->pipelineOpacityMicromap |= enabled->pipelineOpacityMicromap == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM: {
-                const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM *>(pNext);
+                const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM*>(pNext);
                 features->performanceCountersByRegion |= enabled->performanceCountersByRegion == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM: {
-                const VkPhysicalDeviceShaderInstrumentationFeaturesARM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationFeaturesARM *>(pNext);
+                const VkPhysicalDeviceShaderInstrumentationFeaturesARM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationFeaturesARM*>(pNext);
                 features->shaderInstrumentation |= enabled->shaderInstrumentation == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: {
-                const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*>(pNext);
                 features->vertexAttributeRobustness |= enabled->vertexAttributeRobustness == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: {
-                const VkPhysicalDeviceFormatPackFeaturesARM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceFormatPackFeaturesARM *>(pNext);
+                const VkPhysicalDeviceFormatPackFeaturesARM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceFormatPackFeaturesARM*>(pNext);
                 features->formatPack |= enabled->formatPack == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: {
-                const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *>(pNext);
+                const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*>(pNext);
                 features->fragmentDensityMapLayered |= enabled->fragmentDensityMapLayered == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV: {
-                const VkPhysicalDevicePresentMeteringFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV *>(pNext);
+                const VkPhysicalDevicePresentMeteringFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV*>(pNext);
                 features->presentMetering |= enabled->presentMetering == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT: {
-                const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT*>(pNext);
                 features->multisampledRenderToSwapchain |= enabled->multisampledRenderToSwapchain == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: {
-                const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT*>(pNext);
                 features->zeroInitializeDeviceMemory |= enabled->zeroInitializeDeviceMemory == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT: {
-                const VkPhysicalDeviceShader64BitIndexingFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShader64BitIndexingFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShader64BitIndexingFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShader64BitIndexingFeaturesEXT*>(pNext);
                 features->shader64BitIndexing |= enabled->shader64BitIndexing == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: {
-                const VkPhysicalDeviceCustomResolveFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCustomResolveFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceCustomResolveFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCustomResolveFeaturesEXT*>(pNext);
                 features->customResolve |= enabled->customResolve == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: {
-                const VkPhysicalDeviceDataGraphModelFeaturesQCOM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM *>(pNext);
+                const VkPhysicalDeviceDataGraphModelFeaturesQCOM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM*>(pNext);
                 features->dataGraphModel |= enabled->dataGraphModel == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM: {
-                const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM *>(pNext);
+                const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM*>(pNext);
                 features->dataGraphOpticalFlow |= enabled->dataGraphOpticalFlow == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: {
-                const VkPhysicalDeviceShaderLongVectorFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderLongVectorFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShaderLongVectorFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderLongVectorFeaturesEXT*>(pNext);
                 features->longVector |= enabled->longVector == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: {
-                const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *>(pNext);
+                const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC*>(pNext);
                 features->pipelineCacheIncrementalMode |= enabled->pipelineCacheIncrementalMode == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT: {
-                const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT*>(pNext);
                 features->shaderUniformBufferUnsizedArray |= enabled->shaderUniformBufferUnsizedArray == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV: {
-                const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV *>(pNext);
+                const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV*>(pNext);
                 features->computeOccupancyPriority |= enabled->computeOccupancyPriority == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT: {
-                const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*>(pNext);
                 features->shaderSubgroupPartitioned |= enabled->shaderSubgroupPartitioned == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OCP_MICROSCALING_TYPES_FEATURES_EXT: {
-                const VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT*>(pNext);
                 features->shaderFloat4 |= enabled->shaderFloat4 == VK_TRUE;
                 features->shaderFloat6 |= enabled->shaderFloat6 == VK_TRUE;
                 features->shaderFloat8UnsignedE8M0 |= enabled->shaderFloat8UnsignedE8M0 == VK_TRUE;
@@ -2111,8 +2111,8 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE: {
-                const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE *>(pNext);
+                const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE*>(pNext);
                 features->shaderMixedFloatDotProductFloat16AccFloat32 |=
                     enabled->shaderMixedFloatDotProductFloat16AccFloat32 == VK_TRUE;
                 features->shaderMixedFloatDotProductFloat16AccFloat16 |=
@@ -2123,32 +2123,32 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC: {
-                const VkPhysicalDeviceThrottleHintFeaturesSEC *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceThrottleHintFeaturesSEC *>(pNext);
+                const VkPhysicalDeviceThrottleHintFeaturesSEC* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceThrottleHintFeaturesSEC*>(pNext);
                 features->throttleHint |= enabled->throttleHint == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM: {
-                const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM *>(pNext);
+                const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM*>(pNext);
                 features->dataGraphNeuralAcceleratorStatistics |= enabled->dataGraphNeuralAcceleratorStatistics == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT: {
-                const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT *>(pNext);
+                const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT*>(pNext);
                 features->primitiveRestartIndex |= enabled->primitiveRestartIndex == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV: {
-                const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV *>(pNext);
+                const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV*>(pNext);
                 features->cooperativeMatrixDecodeVector |= enabled->cooperativeMatrixDecodeVector == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
-                const VkPhysicalDeviceAccelerationStructureFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceAccelerationStructureFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(pNext);
                 features->accelerationStructure |= enabled->accelerationStructure == VK_TRUE;
                 features->accelerationStructureCaptureReplay |= enabled->accelerationStructureCaptureReplay == VK_TRUE;
                 features->accelerationStructureIndirectBuild |= enabled->accelerationStructureIndirectBuild == VK_TRUE;
@@ -2158,8 +2158,8 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
-                const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(pNext);
                 features->rayTracingPipeline |= enabled->rayTracingPipeline == VK_TRUE;
                 features->rayTracingPipelineShaderGroupHandleCaptureReplay |=
                     enabled->rayTracingPipelineShaderGroupHandleCaptureReplay == VK_TRUE;
@@ -2170,14 +2170,14 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
-                const VkPhysicalDeviceRayQueryFeaturesKHR *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR *>(pNext);
+                const VkPhysicalDeviceRayQueryFeaturesKHR* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(pNext);
                 features->rayQuery |= enabled->rayQuery == VK_TRUE;
                 break;
             }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
-                const VkPhysicalDeviceMeshShaderFeaturesEXT *enabled =
-                    reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT *>(pNext);
+                const VkPhysicalDeviceMeshShaderFeaturesEXT* enabled =
+                    reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(pNext);
                 features->taskShader |= enabled->taskShader == VK_TRUE;
                 features->meshShader |= enabled->meshShader == VK_TRUE;
                 features->multiviewMeshShader |= enabled->multiviewMeshShader == VK_TRUE;
diff --git a/layers/vulkansc/generated/device_features.h b/layers/vulkansc/generated/device_features.h
index 0febe6217..347b9ce4a 100644
--- a/layers/vulkansc/generated/device_features.h
+++ b/layers/vulkansc/generated/device_features.h
@@ -1170,6 +1170,6 @@ struct DeviceFeatures {
     bool zeroInitializeDeviceMemory;
 };
 
-void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatures *features, const APIVersion &api_version);
+void GetEnabledDeviceFeatures(const VkDeviceCreateInfo* pCreateInfo, DeviceFeatures* features, const APIVersion& api_version);
 
 // NOLINTEND
diff --git a/layers/vulkansc/generated/dispatch_object.cpp b/layers/vulkansc/generated/dispatch_object.cpp
index 6442100d7..3129f3ed3 100644
--- a/layers/vulkansc/generated/dispatch_object.cpp
+++ b/layers/vulkansc/generated/dispatch_object.cpp
@@ -794,7 +794,9 @@ void DispatchDevice::FreeMemory(VkDevice device, VkDeviceMemory memory, const Vk
 VkResult DispatchDevice::MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size,
                                    VkMemoryMapFlags flags, void** ppData) {
     if (!wrap_handles) return device_dispatch_table.MapMemory(device, memory, offset, size, flags, ppData);
-    { memory = Unwrap(memory); }
+    {
+        memory = Unwrap(memory);
+    }
     VkResult result = device_dispatch_table.MapMemory(device, memory, offset, size, flags, ppData);
 
     return result;
@@ -802,7 +804,9 @@ VkResult DispatchDevice::MapMemory(VkDevice device, VkDeviceMemory memory, VkDev
 
 void DispatchDevice::UnmapMemory(VkDevice device, VkDeviceMemory memory) {
     if (!wrap_handles) return device_dispatch_table.UnmapMemory(device, memory);
-    { memory = Unwrap(memory); }
+    {
+        memory = Unwrap(memory);
+    }
     device_dispatch_table.UnmapMemory(device, memory);
 }
 
@@ -856,7 +860,9 @@ VkResult DispatchDevice::InvalidateMappedMemoryRanges(VkDevice device, uint32_t
 
 void DispatchDevice::GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
     if (!wrap_handles) return device_dispatch_table.GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
-    { memory = Unwrap(memory); }
+    {
+        memory = Unwrap(memory);
+    }
     device_dispatch_table.GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
 }
 
@@ -884,13 +890,17 @@ VkResult DispatchDevice::BindImageMemory(VkDevice device, VkImage image, VkDevic
 
 void DispatchDevice::GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
     if (!wrap_handles) return device_dispatch_table.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
-    { buffer = Unwrap(buffer); }
+    {
+        buffer = Unwrap(buffer);
+    }
     device_dispatch_table.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
 }
 
 void DispatchDevice::GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
     if (!wrap_handles) return device_dispatch_table.GetImageMemoryRequirements(device, image, pMemoryRequirements);
-    { image = Unwrap(image); }
+    {
+        image = Unwrap(image);
+    }
     device_dispatch_table.GetImageMemoryRequirements(device, image, pMemoryRequirements);
 }
 
@@ -899,7 +909,9 @@ void DispatchDevice::GetImageSparseMemoryRequirements(VkDevice device, VkImage i
     if (!wrap_handles)
         return device_dispatch_table.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount,
                                                                       pSparseMemoryRequirements);
-    { image = Unwrap(image); }
+    {
+        image = Unwrap(image);
+    }
     device_dispatch_table.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 }
 
@@ -1028,7 +1040,9 @@ VkResult DispatchDevice::ResetFences(VkDevice device, uint32_t fenceCount, const
 
 VkResult DispatchDevice::GetFenceStatus(VkDevice device, VkFence fence) {
     if (!wrap_handles) return device_dispatch_table.GetFenceStatus(device, fence);
-    { fence = Unwrap(fence); }
+    {
+        fence = Unwrap(fence);
+    }
     VkResult result = device_dispatch_table.GetFenceStatus(device, fence);
 
     return result;
@@ -1100,7 +1114,9 @@ VkResult DispatchDevice::GetQueryPoolResults(VkDevice device, VkQueryPool queryP
                                              size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
     if (!wrap_handles)
         return device_dispatch_table.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
-    { queryPool = Unwrap(queryPool); }
+    {
+        queryPool = Unwrap(queryPool);
+    }
     VkResult result =
         device_dispatch_table.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
 
@@ -1160,7 +1176,9 @@ void DispatchDevice::DestroyImage(VkDevice device, VkImage image, const VkAlloca
 void DispatchDevice::GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource,
                                                VkSubresourceLayout* pLayout) {
     if (!wrap_handles) return device_dispatch_table.GetImageSubresourceLayout(device, image, pSubresource, pLayout);
-    { image = Unwrap(image); }
+    {
+        image = Unwrap(image);
+    }
     device_dispatch_table.GetImageSubresourceLayout(device, image, pSubresource, pLayout);
 }
 
@@ -1207,7 +1225,9 @@ VkResult DispatchDevice::CreateCommandPool(VkDevice device, const VkCommandPoolC
 
 VkResult DispatchDevice::ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
     if (!wrap_handles) return device_dispatch_table.ResetCommandPool(device, commandPool, flags);
-    { commandPool = Unwrap(commandPool); }
+    {
+        commandPool = Unwrap(commandPool);
+    }
     VkResult result = device_dispatch_table.ResetCommandPool(device, commandPool, flags);
 
     return result;
@@ -1274,14 +1294,18 @@ void DispatchDevice::CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage
 void DispatchDevice::CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
                                      VkDeviceSize dataSize, const void* pData) {
     if (!wrap_handles) return device_dispatch_table.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
-    { dstBuffer = Unwrap(dstBuffer); }
+    {
+        dstBuffer = Unwrap(dstBuffer);
+    }
     device_dispatch_table.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
 }
 
 void DispatchDevice::CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size,
                                    uint32_t data) {
     if (!wrap_handles) return device_dispatch_table.CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
-    { dstBuffer = Unwrap(dstBuffer); }
+    {
+        dstBuffer = Unwrap(dstBuffer);
+    }
     device_dispatch_table.CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 }
 
@@ -1331,27 +1355,35 @@ void DispatchDevice::CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelin
 void DispatchDevice::CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
                                    VkQueryControlFlags flags) {
     if (!wrap_handles) return device_dispatch_table.CmdBeginQuery(commandBuffer, queryPool, query, flags);
-    { queryPool = Unwrap(queryPool); }
+    {
+        queryPool = Unwrap(queryPool);
+    }
     device_dispatch_table.CmdBeginQuery(commandBuffer, queryPool, query, flags);
 }
 
 void DispatchDevice::CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {
     if (!wrap_handles) return device_dispatch_table.CmdEndQuery(commandBuffer, queryPool, query);
-    { queryPool = Unwrap(queryPool); }
+    {
+        queryPool = Unwrap(queryPool);
+    }
     device_dispatch_table.CmdEndQuery(commandBuffer, queryPool, query);
 }
 
 void DispatchDevice::CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
                                        uint32_t queryCount) {
     if (!wrap_handles) return device_dispatch_table.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
-    { queryPool = Unwrap(queryPool); }
+    {
+        queryPool = Unwrap(queryPool);
+    }
     device_dispatch_table.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
 }
 
 void DispatchDevice::CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool,
                                        uint32_t query) {
     if (!wrap_handles) return device_dispatch_table.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
-    { queryPool = Unwrap(queryPool); }
+    {
+        queryPool = Unwrap(queryPool);
+    }
     device_dispatch_table.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
 }
 
@@ -1393,7 +1425,9 @@ void DispatchDevice::DestroyEvent(VkDevice device, VkEvent event, const VkAlloca
 
 VkResult DispatchDevice::GetEventStatus(VkDevice device, VkEvent event) {
     if (!wrap_handles) return device_dispatch_table.GetEventStatus(device, event);
-    { event = Unwrap(event); }
+    {
+        event = Unwrap(event);
+    }
     VkResult result = device_dispatch_table.GetEventStatus(device, event);
 
     return result;
@@ -1401,7 +1435,9 @@ VkResult DispatchDevice::GetEventStatus(VkDevice device, VkEvent event) {
 
 VkResult DispatchDevice::SetEvent(VkDevice device, VkEvent event) {
     if (!wrap_handles) return device_dispatch_table.SetEvent(device, event);
-    { event = Unwrap(event); }
+    {
+        event = Unwrap(event);
+    }
     VkResult result = device_dispatch_table.SetEvent(device, event);
 
     return result;
@@ -1409,7 +1445,9 @@ VkResult DispatchDevice::SetEvent(VkDevice device, VkEvent event) {
 
 VkResult DispatchDevice::ResetEvent(VkDevice device, VkEvent event) {
     if (!wrap_handles) return device_dispatch_table.ResetEvent(device, event);
-    { event = Unwrap(event); }
+    {
+        event = Unwrap(event);
+    }
     VkResult result = device_dispatch_table.ResetEvent(device, event);
 
     return result;
@@ -1489,7 +1527,9 @@ void DispatchDevice::DestroyPipelineCache(VkDevice device, VkPipelineCache pipel
 
 VkResult DispatchDevice::GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
     if (!wrap_handles) return device_dispatch_table.GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
-    { pipelineCache = Unwrap(pipelineCache); }
+    {
+        pipelineCache = Unwrap(pipelineCache);
+    }
     VkResult result = device_dispatch_table.GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
 
     return result;
@@ -1702,7 +1742,9 @@ void DispatchDevice::UpdateDescriptorSets(VkDevice device, uint32_t descriptorWr
 
 void DispatchDevice::CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
     if (!wrap_handles) return device_dispatch_table.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
-    { pipeline = Unwrap(pipeline); }
+    {
+        pipeline = Unwrap(pipeline);
+    }
     device_dispatch_table.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 }
 
@@ -1734,7 +1776,9 @@ void DispatchDevice::CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage i
                                         const VkImageSubresourceRange* pRanges) {
     if (!wrap_handles)
         return device_dispatch_table.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
-    { image = Unwrap(image); }
+    {
+        image = Unwrap(image);
+    }
     device_dispatch_table.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
 }
 
@@ -1744,19 +1788,25 @@ void DispatchDevice::CmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCo
 
 void DispatchDevice::CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
     if (!wrap_handles) return device_dispatch_table.CmdDispatchIndirect(commandBuffer, buffer, offset);
-    { buffer = Unwrap(buffer); }
+    {
+        buffer = Unwrap(buffer);
+    }
     device_dispatch_table.CmdDispatchIndirect(commandBuffer, buffer, offset);
 }
 
 void DispatchDevice::CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
     if (!wrap_handles) return device_dispatch_table.CmdSetEvent(commandBuffer, event, stageMask);
-    { event = Unwrap(event); }
+    {
+        event = Unwrap(event);
+    }
     device_dispatch_table.CmdSetEvent(commandBuffer, event, stageMask);
 }
 
 void DispatchDevice::CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
     if (!wrap_handles) return device_dispatch_table.CmdResetEvent(commandBuffer, event, stageMask);
-    { event = Unwrap(event); }
+    {
+        event = Unwrap(event);
+    }
     device_dispatch_table.CmdResetEvent(commandBuffer, event, stageMask);
 }
 
@@ -1815,7 +1865,9 @@ void DispatchDevice::CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t event
 void DispatchDevice::CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags,
                                       uint32_t offset, uint32_t size, const void* pValues) {
     if (!wrap_handles) return device_dispatch_table.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
-    { layout = Unwrap(layout); }
+    {
+        layout = Unwrap(layout);
+    }
     device_dispatch_table.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
 }
 
@@ -1855,7 +1907,9 @@ void DispatchDevice::DestroyFramebuffer(VkDevice device, VkFramebuffer framebuff
 
 void DispatchDevice::GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
     if (!wrap_handles) return device_dispatch_table.GetRenderAreaGranularity(device, renderPass, pGranularity);
-    { renderPass = Unwrap(renderPass); }
+    {
+        renderPass = Unwrap(renderPass);
+    }
     device_dispatch_table.GetRenderAreaGranularity(device, renderPass, pGranularity);
 }
 
@@ -1901,7 +1955,9 @@ void DispatchDevice::CmdSetStencilReference(VkCommandBuffer commandBuffer, VkSte
 void DispatchDevice::CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                         VkIndexType indexType) {
     if (!wrap_handles) return device_dispatch_table.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
-    { buffer = Unwrap(buffer); }
+    {
+        buffer = Unwrap(buffer);
+    }
     device_dispatch_table.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
 }
 
@@ -1937,14 +1993,18 @@ void DispatchDevice::CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t inde
 void DispatchDevice::CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount,
                                      uint32_t stride) {
     if (!wrap_handles) return device_dispatch_table.CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
-    { buffer = Unwrap(buffer); }
+    {
+        buffer = Unwrap(buffer);
+    }
     device_dispatch_table.CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
 }
 
 void DispatchDevice::CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount,
                                             uint32_t stride) {
     if (!wrap_handles) return device_dispatch_table.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
-    { buffer = Unwrap(buffer); }
+    {
+        buffer = Unwrap(buffer);
+    }
     device_dispatch_table.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
 }
 
@@ -1968,7 +2028,9 @@ void DispatchDevice::CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, Vk
     if (!wrap_handles)
         return device_dispatch_table.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount,
                                                                pRanges);
-    { image = Unwrap(image); }
+    {
+        image = Unwrap(image);
+    }
     device_dispatch_table.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
 }
 
@@ -2138,7 +2200,9 @@ void DispatchInstance::GetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalD
 
 void DispatchDevice::TrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {
     if (!wrap_handles) return device_dispatch_table.TrimCommandPool(device, commandPool, flags);
-    { commandPool = Unwrap(commandPool); }
+    {
+        commandPool = Unwrap(commandPool);
+    }
     device_dispatch_table.TrimCommandPool(device, commandPool, flags);
 }
 
@@ -2217,13 +2281,17 @@ void DispatchDevice::DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcb
 
 void DispatchDevice::ResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
     if (!wrap_handles) return device_dispatch_table.ResetQueryPool(device, queryPool, firstQuery, queryCount);
-    { queryPool = Unwrap(queryPool); }
+    {
+        queryPool = Unwrap(queryPool);
+    }
     device_dispatch_table.ResetQueryPool(device, queryPool, firstQuery, queryCount);
 }
 
 VkResult DispatchDevice::GetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) {
     if (!wrap_handles) return device_dispatch_table.GetSemaphoreCounterValue(device, semaphore, pValue);
-    { semaphore = Unwrap(semaphore); }
+    {
+        semaphore = Unwrap(semaphore);
+    }
     VkResult result = device_dispatch_table.GetSemaphoreCounterValue(device, semaphore, pValue);
 
     return result;
@@ -2461,7 +2529,9 @@ void DispatchDevice::CmdPipelineBarrier2(VkCommandBuffer commandBuffer, const Vk
 void DispatchDevice::CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool,
                                         uint32_t query) {
     if (!wrap_handles) return device_dispatch_table.CmdWriteTimestamp2(commandBuffer, stage, queryPool, query);
-    { queryPool = Unwrap(queryPool); }
+    {
+        queryPool = Unwrap(queryPool);
+    }
     device_dispatch_table.CmdWriteTimestamp2(commandBuffer, stage, queryPool, query);
 }
 
@@ -2636,7 +2706,9 @@ void DispatchDevice::CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
 
 void DispatchDevice::CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) {
     if (!wrap_handles) return device_dispatch_table.CmdResetEvent2(commandBuffer, event, stageMask);
-    { event = Unwrap(event); }
+    {
+        event = Unwrap(event);
+    }
     device_dispatch_table.CmdResetEvent2(commandBuffer, event, stageMask);
 }
 
@@ -2894,7 +2966,9 @@ void DispatchDevice::GetDeviceImageSubresourceLayout(VkDevice device, const VkDe
 void DispatchDevice::GetImageSubresourceLayout2(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource,
                                                 VkSubresourceLayout2* pLayout) {
     if (!wrap_handles) return device_dispatch_table.GetImageSubresourceLayout2(device, image, pSubresource, pLayout);
-    { image = Unwrap(image); }
+    {
+        image = Unwrap(image);
+    }
     device_dispatch_table.GetImageSubresourceLayout2(device, image, pSubresource, pLayout);
 }
 
@@ -3156,7 +3230,9 @@ void DispatchDevice::CmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t l
 void DispatchDevice::CmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size,
                                          VkIndexType indexType) {
     if (!wrap_handles) return device_dispatch_table.CmdBindIndexBuffer2(commandBuffer, buffer, offset, size, indexType);
-    { buffer = Unwrap(buffer); }
+    {
+        buffer = Unwrap(buffer);
+    }
     device_dispatch_table.CmdBindIndexBuffer2(commandBuffer, buffer, offset, size, indexType);
 }
 
@@ -3179,7 +3255,9 @@ void DispatchDevice::GetCommandPoolMemoryConsumption(VkDevice device, VkCommandP
                                                      VkCommandPoolMemoryConsumption* pConsumption) {
     if (!wrap_handles)
         return device_dispatch_table.GetCommandPoolMemoryConsumption(device, commandPool, commandBuffer, pConsumption);
-    { commandPool = Unwrap(commandPool); }
+    {
+        commandPool = Unwrap(commandPool);
+    }
     device_dispatch_table.GetCommandPoolMemoryConsumption(device, commandPool, commandBuffer, pConsumption);
 }
 
@@ -3200,7 +3278,9 @@ VkResult DispatchInstance::GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice p
                                                               VkSurfaceKHR surface, VkBool32* pSupported) {
     if (!wrap_handles)
         return instance_dispatch_table.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
-    { surface = Unwrap(surface); }
+    {
+        surface = Unwrap(surface);
+    }
     VkResult result =
         instance_dispatch_table.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
 
@@ -3211,7 +3291,9 @@ VkResult DispatchInstance::GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDev
                                                                    VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
     if (!wrap_handles)
         return instance_dispatch_table.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
-    { surface = Unwrap(surface); }
+    {
+        surface = Unwrap(surface);
+    }
     VkResult result =
         instance_dispatch_table.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
 
@@ -3223,7 +3305,9 @@ VkResult DispatchInstance::GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice p
     if (!wrap_handles)
         return instance_dispatch_table.GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount,
                                                                           pSurfaceFormats);
-    { surface = Unwrap(surface); }
+    {
+        surface = Unwrap(surface);
+    }
     VkResult result =
         instance_dispatch_table.GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
 
@@ -3235,7 +3319,9 @@ VkResult DispatchInstance::GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDev
     if (!wrap_handles)
         return instance_dispatch_table.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount,
                                                                                pPresentModes);
-    { surface = Unwrap(surface); }
+    {
+        surface = Unwrap(surface);
+    }
     VkResult result =
         instance_dispatch_table.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
 
@@ -3291,7 +3377,9 @@ VkResult DispatchDevice::GetDeviceGroupPresentCapabilitiesKHR(
 VkResult DispatchDevice::GetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface,
                                                               VkDeviceGroupPresentModeFlagsKHR* pModes) {
     if (!wrap_handles) return device_dispatch_table.GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
-    { surface = Unwrap(surface); }
+    {
+        surface = Unwrap(surface);
+    }
     VkResult result = device_dispatch_table.GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
 
     return result;
@@ -3301,7 +3389,9 @@ VkResult DispatchInstance::GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevic
                                                                  uint32_t* pRectCount, VkRect2D* pRects) {
     if (!wrap_handles)
         return instance_dispatch_table.GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
-    { surface = Unwrap(surface); }
+    {
+        surface = Unwrap(surface);
+    }
     VkResult result = instance_dispatch_table.GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
 
     return result;
@@ -3338,7 +3428,9 @@ VkResult DispatchInstance::CreateDisplayModeKHR(VkPhysicalDevice physicalDevice,
                                                 const VkDisplayModeCreateInfoKHR* pCreateInfo,
                                                 const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) {
     if (!wrap_handles) return instance_dispatch_table.CreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
-    { display = Unwrap(display); }
+    {
+        display = Unwrap(display);
+    }
     VkResult result = instance_dispatch_table.CreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
     if (result == VK_SUCCESS) {
         *pMode = WrapNew(*pMode);
@@ -3350,7 +3442,9 @@ VkResult DispatchInstance::GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physi
                                                           uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) {
     if (!wrap_handles)
         return instance_dispatch_table.GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
-    { mode = Unwrap(mode); }
+    {
+        mode = Unwrap(mode);
+    }
     VkResult result = instance_dispatch_table.GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
 
     return result;
@@ -3550,7 +3644,9 @@ VkResult DispatchDevice::GetVideoSessionMemoryRequirementsKHR(VkDevice device, V
     if (!wrap_handles)
         return device_dispatch_table.GetVideoSessionMemoryRequirementsKHR(device, videoSession, pMemoryRequirementsCount,
                                                                           pMemoryRequirements);
-    { videoSession = Unwrap(videoSession); }
+    {
+        videoSession = Unwrap(videoSession);
+    }
     VkResult result = device_dispatch_table.GetVideoSessionMemoryRequirementsKHR(device, videoSession, pMemoryRequirementsCount,
                                                                                  pMemoryRequirements);
 
@@ -3616,7 +3712,9 @@ VkResult DispatchDevice::CreateVideoSessionParametersKHR(VkDevice device, const
 VkResult DispatchDevice::UpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters,
                                                          const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) {
     if (!wrap_handles) return device_dispatch_table.UpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo);
-    { videoSessionParameters = Unwrap(videoSessionParameters); }
+    {
+        videoSessionParameters = Unwrap(videoSessionParameters);
+    }
     VkResult result = device_dispatch_table.UpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo);
 
     return result;
@@ -3814,7 +3912,9 @@ void DispatchDevice::CmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t
 
 void DispatchDevice::TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {
     if (!wrap_handles) return device_dispatch_table.TrimCommandPoolKHR(device, commandPool, flags);
-    { commandPool = Unwrap(commandPool); }
+    {
+        commandPool = Unwrap(commandPool);
+    }
     device_dispatch_table.TrimCommandPoolKHR(device, commandPool, flags);
 }
 
@@ -4074,7 +4174,9 @@ void DispatchDevice::CmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const V
 
 VkResult DispatchDevice::GetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) {
     if (!wrap_handles) return device_dispatch_table.GetSwapchainStatusKHR(device, swapchain);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     VkResult result = device_dispatch_table.GetSwapchainStatusKHR(device, swapchain);
 
     return result;
@@ -4398,7 +4500,9 @@ void DispatchDevice::CmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffe
 
 VkResult DispatchDevice::GetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) {
     if (!wrap_handles) return device_dispatch_table.GetSemaphoreCounterValueKHR(device, semaphore, pValue);
-    { semaphore = Unwrap(semaphore); }
+    {
+        semaphore = Unwrap(semaphore);
+    }
     VkResult result = device_dispatch_table.GetSemaphoreCounterValueKHR(device, semaphore, pValue);
 
     return result;
@@ -4469,7 +4573,9 @@ void DispatchDevice::CmdSetRenderingInputAttachmentIndicesKHR(
 
 VkResult DispatchDevice::WaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) {
     if (!wrap_handles) return device_dispatch_table.WaitForPresentKHR(device, swapchain, presentId, timeout);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     VkResult result = device_dispatch_table.WaitForPresentKHR(device, swapchain, presentId, timeout);
 
     return result;
@@ -4554,7 +4660,9 @@ void DispatchDevice::DestroyDeferredOperationKHR(VkDevice device, VkDeferredOper
 
 uint32_t DispatchDevice::GetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) {
     if (!wrap_handles) return device_dispatch_table.GetDeferredOperationMaxConcurrencyKHR(device, operation);
-    { operation = Unwrap(operation); }
+    {
+        operation = Unwrap(operation);
+    }
     uint32_t result = device_dispatch_table.GetDeferredOperationMaxConcurrencyKHR(device, operation);
 
     return result;
@@ -4788,7 +4896,9 @@ void DispatchDevice::CmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent even
 
 void DispatchDevice::CmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) {
     if (!wrap_handles) return device_dispatch_table.CmdResetEvent2KHR(commandBuffer, event, stageMask);
-    { event = Unwrap(event); }
+    {
+        event = Unwrap(event);
+    }
     device_dispatch_table.CmdResetEvent2KHR(commandBuffer, event, stageMask);
 }
 
@@ -4869,7 +4979,9 @@ void DispatchDevice::CmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const
 void DispatchDevice::CmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool,
                                            uint32_t query) {
     if (!wrap_handles) return device_dispatch_table.CmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query);
-    { queryPool = Unwrap(queryPool); }
+    {
+        queryPool = Unwrap(queryPool);
+    }
     device_dispatch_table.CmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query);
 }
 
@@ -4989,7 +5101,9 @@ void DispatchDevice::CmdCopyQueryPoolResultsToMemoryKHR(VkCommandBuffer commandB
     if (!wrap_handles)
         return device_dispatch_table.CmdCopyQueryPoolResultsToMemoryKHR(commandBuffer, queryPool, firstQuery, queryCount, pDstRange,
                                                                         dstFlags, queryResultFlags);
-    { queryPool = Unwrap(queryPool); }
+    {
+        queryPool = Unwrap(queryPool);
+    }
     device_dispatch_table.CmdCopyQueryPoolResultsToMemoryKHR(commandBuffer, queryPool, firstQuery, queryCount, pDstRange, dstFlags,
                                                              queryResultFlags);
 }
@@ -5204,7 +5318,9 @@ void DispatchDevice::GetDeviceImageSparseMemoryRequirementsKHR(VkDevice device,
 void DispatchDevice::CmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size,
                                             VkIndexType indexType) {
     if (!wrap_handles) return device_dispatch_table.CmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType);
-    { buffer = Unwrap(buffer); }
+    {
+        buffer = Unwrap(buffer);
+    }
     device_dispatch_table.CmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType);
 }
 
@@ -5221,14 +5337,18 @@ void DispatchDevice::GetDeviceImageSubresourceLayoutKHR(VkDevice device, const V
 void DispatchDevice::GetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource,
                                                    VkSubresourceLayout2* pLayout) {
     if (!wrap_handles) return device_dispatch_table.GetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout);
-    { image = Unwrap(image); }
+    {
+        image = Unwrap(image);
+    }
     device_dispatch_table.GetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout);
 }
 
 VkResult DispatchDevice::WaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain,
                                             const VkPresentWait2InfoKHR* pPresentWait2Info) {
     if (!wrap_handles) return device_dispatch_table.WaitForPresent2KHR(device, swapchain, pPresentWait2Info);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     VkResult result = device_dispatch_table.WaitForPresent2KHR(device, swapchain, pPresentWait2Info);
 
     return result;
@@ -5648,13 +5768,17 @@ void DispatchDevice::CmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, u
 void DispatchDevice::CmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
                                              VkQueryControlFlags flags, uint32_t index) {
     if (!wrap_handles) return device_dispatch_table.CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
-    { queryPool = Unwrap(queryPool); }
+    {
+        queryPool = Unwrap(queryPool);
+    }
     device_dispatch_table.CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
 }
 
 void DispatchDevice::CmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) {
     if (!wrap_handles) return device_dispatch_table.CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
-    { queryPool = Unwrap(queryPool); }
+    {
+        queryPool = Unwrap(queryPool);
+    }
     device_dispatch_table.CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
 }
 
@@ -5664,7 +5788,9 @@ void DispatchDevice::CmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,
     if (!wrap_handles)
         return device_dispatch_table.CmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer,
                                                                  counterBufferOffset, counterOffset, vertexStride);
-    { counterBuffer = Unwrap(counterBuffer); }
+    {
+        counterBuffer = Unwrap(counterBuffer);
+    }
     device_dispatch_table.CmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer,
                                                       counterBufferOffset, counterOffset, vertexStride);
 }
@@ -5779,7 +5905,9 @@ uint64_t DispatchDevice::GetImageViewHandle64NVX(VkDevice device, const VkImageV
 VkResult DispatchDevice::GetImageViewAddressNVX(VkDevice device, VkImageView imageView,
                                                 VkImageViewAddressPropertiesNVX* pProperties) {
     if (!wrap_handles) return device_dispatch_table.GetImageViewAddressNVX(device, imageView, pProperties);
-    { imageView = Unwrap(imageView); }
+    {
+        imageView = Unwrap(imageView);
+    }
     VkResult result = device_dispatch_table.GetImageViewAddressNVX(device, imageView, pProperties);
 
     return result;
@@ -5822,7 +5950,9 @@ void DispatchDevice::CmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffe
 VkResult DispatchDevice::GetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage,
                                           VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) {
     if (!wrap_handles) return device_dispatch_table.GetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
-    { pipeline = Unwrap(pipeline); }
+    {
+        pipeline = Unwrap(pipeline);
+    }
     VkResult result = device_dispatch_table.GetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
 
     return result;
@@ -5856,7 +5986,9 @@ VkResult DispatchInstance::GetPhysicalDeviceExternalImageFormatPropertiesNV(
 VkResult DispatchDevice::GetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory,
                                                 VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) {
     if (!wrap_handles) return device_dispatch_table.GetMemoryWin32HandleNV(device, memory, handleType, pHandle);
-    { memory = Unwrap(memory); }
+    {
+        memory = Unwrap(memory);
+    }
     VkResult result = device_dispatch_table.GetMemoryWin32HandleNV(device, memory, handleType, pHandle);
 
     return result;
@@ -5906,7 +6038,9 @@ void DispatchDevice::CmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uin
 
 VkResult DispatchInstance::ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
     if (!wrap_handles) return instance_dispatch_table.ReleaseDisplayEXT(physicalDevice, display);
-    { display = Unwrap(display); }
+    {
+        display = Unwrap(display);
+    }
     VkResult result = instance_dispatch_table.ReleaseDisplayEXT(physicalDevice, display);
 
     return result;
@@ -5915,7 +6049,9 @@ VkResult DispatchInstance::ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, Vk
 
 VkResult DispatchInstance::AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) {
     if (!wrap_handles) return instance_dispatch_table.AcquireXlibDisplayEXT(physicalDevice, dpy, display);
-    { display = Unwrap(display); }
+    {
+        display = Unwrap(display);
+    }
     VkResult result = instance_dispatch_table.AcquireXlibDisplayEXT(physicalDevice, dpy, display);
 
     return result;
@@ -5937,7 +6073,9 @@ VkResult DispatchInstance::GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDe
                                                                     VkSurfaceCapabilities2EXT* pSurfaceCapabilities) {
     if (!wrap_handles)
         return instance_dispatch_table.GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
-    { surface = Unwrap(surface); }
+    {
+        surface = Unwrap(surface);
+    }
     VkResult result =
         instance_dispatch_table.GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
 
@@ -5947,7 +6085,9 @@ VkResult DispatchInstance::GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDe
 VkResult DispatchDevice::DisplayPowerControlEXT(VkDevice device, VkDisplayKHR display,
                                                 const VkDisplayPowerInfoEXT* pDisplayPowerInfo) {
     if (!wrap_handles) return device_dispatch_table.DisplayPowerControlEXT(device, display, pDisplayPowerInfo);
-    { display = Unwrap(display); }
+    {
+        display = Unwrap(display);
+    }
     VkResult result = device_dispatch_table.DisplayPowerControlEXT(device, display, pDisplayPowerInfo);
 
     return result;
@@ -5968,7 +6108,9 @@ VkResult DispatchDevice::RegisterDisplayEventEXT(VkDevice device, VkDisplayKHR d
                                                  const VkDisplayEventInfoEXT* pDisplayEventInfo,
                                                  const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
     if (!wrap_handles) return device_dispatch_table.RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
-    { display = Unwrap(display); }
+    {
+        display = Unwrap(display);
+    }
     VkResult result = device_dispatch_table.RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
     if (result == VK_SUCCESS) {
         *pFence = WrapNew(*pFence);
@@ -5979,7 +6121,9 @@ VkResult DispatchDevice::RegisterDisplayEventEXT(VkDevice device, VkDisplayKHR d
 VkResult DispatchDevice::GetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter,
                                                 uint64_t* pCounterValue) {
     if (!wrap_handles) return device_dispatch_table.GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     VkResult result = device_dispatch_table.GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
 
     return result;
@@ -5988,7 +6132,9 @@ VkResult DispatchDevice::GetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR
 VkResult DispatchDevice::GetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain,
                                                        VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
     if (!wrap_handles) return device_dispatch_table.GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     VkResult result = device_dispatch_table.GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
 
     return result;
@@ -6000,7 +6146,9 @@ VkResult DispatchDevice::GetPastPresentationTimingGOOGLE(VkDevice device, VkSwap
     if (!wrap_handles)
         return device_dispatch_table.GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount,
                                                                      pPresentationTimings);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     VkResult result =
         device_dispatch_table.GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
 
@@ -6185,7 +6333,9 @@ VkResult DispatchDevice::GetGpaDeviceClockInfoAMD(VkDevice device, VkGpaDeviceGe
 
 VkResult DispatchDevice::CmdBeginGpaSessionAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession) {
     if (!wrap_handles) return device_dispatch_table.CmdBeginGpaSessionAMD(commandBuffer, gpaSession);
-    { gpaSession = Unwrap(gpaSession); }
+    {
+        gpaSession = Unwrap(gpaSession);
+    }
     VkResult result = device_dispatch_table.CmdBeginGpaSessionAMD(commandBuffer, gpaSession);
 
     return result;
@@ -6193,7 +6343,9 @@ VkResult DispatchDevice::CmdBeginGpaSessionAMD(VkCommandBuffer commandBuffer, Vk
 
 VkResult DispatchDevice::CmdEndGpaSessionAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession) {
     if (!wrap_handles) return device_dispatch_table.CmdEndGpaSessionAMD(commandBuffer, gpaSession);
-    { gpaSession = Unwrap(gpaSession); }
+    {
+        gpaSession = Unwrap(gpaSession);
+    }
     VkResult result = device_dispatch_table.CmdEndGpaSessionAMD(commandBuffer, gpaSession);
 
     return result;
@@ -6202,7 +6354,9 @@ VkResult DispatchDevice::CmdEndGpaSessionAMD(VkCommandBuffer commandBuffer, VkGp
 VkResult DispatchDevice::CmdBeginGpaSampleAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession,
                                               const VkGpaSampleBeginInfoAMD* pGpaSampleBeginInfo, uint32_t* pSampleID) {
     if (!wrap_handles) return device_dispatch_table.CmdBeginGpaSampleAMD(commandBuffer, gpaSession, pGpaSampleBeginInfo, pSampleID);
-    { gpaSession = Unwrap(gpaSession); }
+    {
+        gpaSession = Unwrap(gpaSession);
+    }
     VkResult result = device_dispatch_table.CmdBeginGpaSampleAMD(commandBuffer, gpaSession, pGpaSampleBeginInfo, pSampleID);
 
     return result;
@@ -6210,13 +6364,17 @@ VkResult DispatchDevice::CmdBeginGpaSampleAMD(VkCommandBuffer commandBuffer, VkG
 
 void DispatchDevice::CmdEndGpaSampleAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, uint32_t sampleID) {
     if (!wrap_handles) return device_dispatch_table.CmdEndGpaSampleAMD(commandBuffer, gpaSession, sampleID);
-    { gpaSession = Unwrap(gpaSession); }
+    {
+        gpaSession = Unwrap(gpaSession);
+    }
     device_dispatch_table.CmdEndGpaSampleAMD(commandBuffer, gpaSession, sampleID);
 }
 
 VkResult DispatchDevice::GetGpaSessionStatusAMD(VkDevice device, VkGpaSessionAMD gpaSession) {
     if (!wrap_handles) return device_dispatch_table.GetGpaSessionStatusAMD(device, gpaSession);
-    { gpaSession = Unwrap(gpaSession); }
+    {
+        gpaSession = Unwrap(gpaSession);
+    }
     VkResult result = device_dispatch_table.GetGpaSessionStatusAMD(device, gpaSession);
 
     return result;
@@ -6225,7 +6383,9 @@ VkResult DispatchDevice::GetGpaSessionStatusAMD(VkDevice device, VkGpaSessionAMD
 VkResult DispatchDevice::GetGpaSessionResultsAMD(VkDevice device, VkGpaSessionAMD gpaSession, uint32_t sampleID,
                                                  size_t* pSizeInBytes, void* pData) {
     if (!wrap_handles) return device_dispatch_table.GetGpaSessionResultsAMD(device, gpaSession, sampleID, pSizeInBytes, pData);
-    { gpaSession = Unwrap(gpaSession); }
+    {
+        gpaSession = Unwrap(gpaSession);
+    }
     VkResult result = device_dispatch_table.GetGpaSessionResultsAMD(device, gpaSession, sampleID, pSizeInBytes, pData);
 
     return result;
@@ -6233,7 +6393,9 @@ VkResult DispatchDevice::GetGpaSessionResultsAMD(VkDevice device, VkGpaSessionAM
 
 VkResult DispatchDevice::ResetGpaSessionAMD(VkDevice device, VkGpaSessionAMD gpaSession) {
     if (!wrap_handles) return device_dispatch_table.ResetGpaSessionAMD(device, gpaSession);
-    { gpaSession = Unwrap(gpaSession); }
+    {
+        gpaSession = Unwrap(gpaSession);
+    }
     VkResult result = device_dispatch_table.ResetGpaSessionAMD(device, gpaSession);
 
     return result;
@@ -6241,7 +6403,9 @@ VkResult DispatchDevice::ResetGpaSessionAMD(VkDevice device, VkGpaSessionAMD gpa
 
 void DispatchDevice::CmdCopyGpaSessionResultsAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession) {
     if (!wrap_handles) return device_dispatch_table.CmdCopyGpaSessionResultsAMD(commandBuffer, gpaSession);
-    { gpaSession = Unwrap(gpaSession); }
+    {
+        gpaSession = Unwrap(gpaSession);
+    }
     device_dispatch_table.CmdCopyGpaSessionResultsAMD(commandBuffer, gpaSession);
 }
 #ifdef VK_ENABLE_BETA_EXTENSIONS
@@ -6302,7 +6466,9 @@ VkResult DispatchDevice::CreateExecutionGraphPipelinesAMDX(VkDevice device, VkPi
 VkResult DispatchDevice::GetExecutionGraphPipelineScratchSizeAMDX(VkDevice device, VkPipeline executionGraph,
                                                                   VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) {
     if (!wrap_handles) return device_dispatch_table.GetExecutionGraphPipelineScratchSizeAMDX(device, executionGraph, pSizeInfo);
-    { executionGraph = Unwrap(executionGraph); }
+    {
+        executionGraph = Unwrap(executionGraph);
+    }
     VkResult result = device_dispatch_table.GetExecutionGraphPipelineScratchSizeAMDX(device, executionGraph, pSizeInfo);
 
     return result;
@@ -6313,7 +6479,9 @@ VkResult DispatchDevice::GetExecutionGraphPipelineNodeIndexAMDX(VkDevice device,
                                                                 uint32_t* pNodeIndex) {
     if (!wrap_handles)
         return device_dispatch_table.GetExecutionGraphPipelineNodeIndexAMDX(device, executionGraph, pNodeInfo, pNodeIndex);
-    { executionGraph = Unwrap(executionGraph); }
+    {
+        executionGraph = Unwrap(executionGraph);
+    }
     VkResult result = device_dispatch_table.GetExecutionGraphPipelineNodeIndexAMDX(device, executionGraph, pNodeInfo, pNodeIndex);
 
     return result;
@@ -6323,7 +6491,9 @@ void DispatchDevice::CmdInitializeGraphScratchMemoryAMDX(VkCommandBuffer command
                                                          VkDeviceAddress scratch, VkDeviceSize scratchSize) {
     if (!wrap_handles)
         return device_dispatch_table.CmdInitializeGraphScratchMemoryAMDX(commandBuffer, executionGraph, scratch, scratchSize);
-    { executionGraph = Unwrap(executionGraph); }
+    {
+        executionGraph = Unwrap(executionGraph);
+    }
     device_dispatch_table.CmdInitializeGraphScratchMemoryAMDX(commandBuffer, executionGraph, scratch, scratchSize);
 }
 
@@ -6445,7 +6615,9 @@ void DispatchInstance::GetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevic
 VkResult DispatchDevice::GetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image,
                                                                 VkImageDrmFormatModifierPropertiesEXT* pProperties) {
     if (!wrap_handles) return device_dispatch_table.GetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
-    { image = Unwrap(image); }
+    {
+        image = Unwrap(image);
+    }
     VkResult result = device_dispatch_table.GetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
 
     return result;
@@ -6493,7 +6665,9 @@ VkResult DispatchDevice::MergeValidationCachesEXT(VkDevice device, VkValidationC
 VkResult DispatchDevice::GetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize,
                                                    void* pData) {
     if (!wrap_handles) return device_dispatch_table.GetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
-    { validationCache = Unwrap(validationCache); }
+    {
+        validationCache = Unwrap(validationCache);
+    }
     VkResult result = device_dispatch_table.GetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
 
     return result;
@@ -6501,7 +6675,9 @@ VkResult DispatchDevice::GetValidationCacheDataEXT(VkDevice device, VkValidation
 
 void DispatchDevice::CmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) {
     if (!wrap_handles) return device_dispatch_table.CmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout);
-    { imageView = Unwrap(imageView); }
+    {
+        imageView = Unwrap(imageView);
+    }
     device_dispatch_table.CmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout);
 }
 
@@ -6696,7 +6872,9 @@ VkResult DispatchDevice::GetRayTracingShaderGroupHandlesKHR(VkDevice device, VkP
                                                             uint32_t groupCount, size_t dataSize, void* pData) {
     if (!wrap_handles)
         return device_dispatch_table.GetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
-    { pipeline = Unwrap(pipeline); }
+    {
+        pipeline = Unwrap(pipeline);
+    }
     VkResult result =
         device_dispatch_table.GetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
 
@@ -6707,7 +6885,9 @@ VkResult DispatchDevice::GetRayTracingShaderGroupHandlesNV(VkDevice device, VkPi
                                                            uint32_t groupCount, size_t dataSize, void* pData) {
     if (!wrap_handles)
         return device_dispatch_table.GetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData);
-    { pipeline = Unwrap(pipeline); }
+    {
+        pipeline = Unwrap(pipeline);
+    }
     VkResult result =
         device_dispatch_table.GetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData);
 
@@ -6718,7 +6898,9 @@ VkResult DispatchDevice::GetAccelerationStructureHandleNV(VkDevice device, VkAcc
                                                           size_t dataSize, void* pData) {
     if (!wrap_handles)
         return device_dispatch_table.GetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
-    { accelerationStructure = Unwrap(accelerationStructure); }
+    {
+        accelerationStructure = Unwrap(accelerationStructure);
+    }
     VkResult result = device_dispatch_table.GetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
 
     return result;
@@ -6749,7 +6931,9 @@ void DispatchDevice::CmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer
 
 VkResult DispatchDevice::CompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) {
     if (!wrap_handles) return device_dispatch_table.CompileDeferredNV(device, pipeline, shader);
-    { pipeline = Unwrap(pipeline); }
+    {
+        pipeline = Unwrap(pipeline);
+    }
     VkResult result = device_dispatch_table.CompileDeferredNV(device, pipeline, shader);
 
     return result;
@@ -6768,14 +6952,18 @@ void DispatchDevice::CmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPi
                                              VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {
     if (!wrap_handles)
         return device_dispatch_table.CmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
-    { dstBuffer = Unwrap(dstBuffer); }
+    {
+        dstBuffer = Unwrap(dstBuffer);
+    }
     device_dispatch_table.CmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
 }
 
 void DispatchDevice::CmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
                                               VkDeviceSize dstOffset, uint32_t marker) {
     if (!wrap_handles) return device_dispatch_table.CmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker);
-    { dstBuffer = Unwrap(dstBuffer); }
+    {
+        dstBuffer = Unwrap(dstBuffer);
+    }
     device_dispatch_table.CmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker);
 }
 
@@ -6818,7 +7006,9 @@ void DispatchDevice::CmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t
 void DispatchDevice::CmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                                 uint32_t drawCount, uint32_t stride) {
     if (!wrap_handles) return device_dispatch_table.CmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
-    { buffer = Unwrap(buffer); }
+    {
+        buffer = Unwrap(buffer);
+    }
     device_dispatch_table.CmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
 }
 
@@ -6862,7 +7052,9 @@ void DispatchDevice::GetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpo
 
 VkResult DispatchDevice::SetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain, uint32_t size) {
     if (!wrap_handles) return device_dispatch_table.SetSwapchainPresentTimingQueueSizeEXT(device, swapchain, size);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     VkResult result = device_dispatch_table.SetSwapchainPresentTimingQueueSizeEXT(device, swapchain, size);
 
     return result;
@@ -6874,7 +7066,9 @@ VkResult DispatchDevice::GetSwapchainTimingPropertiesEXT(VkDevice device, VkSwap
     if (!wrap_handles)
         return device_dispatch_table.GetSwapchainTimingPropertiesEXT(device, swapchain, pSwapchainTimingProperties,
                                                                      pSwapchainTimingPropertiesCounter);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     VkResult result = device_dispatch_table.GetSwapchainTimingPropertiesEXT(device, swapchain, pSwapchainTimingProperties,
                                                                             pSwapchainTimingPropertiesCounter);
 
@@ -6887,7 +7081,9 @@ VkResult DispatchDevice::GetSwapchainTimeDomainPropertiesEXT(VkDevice device, Vk
     if (!wrap_handles)
         return device_dispatch_table.GetSwapchainTimeDomainPropertiesEXT(device, swapchain, pSwapchainTimeDomainProperties,
                                                                          pTimeDomainsCounter);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     VkResult result = device_dispatch_table.GetSwapchainTimeDomainPropertiesEXT(device, swapchain, pSwapchainTimeDomainProperties,
                                                                                 pTimeDomainsCounter);
 
@@ -6964,7 +7160,9 @@ VkResult DispatchDevice::AcquirePerformanceConfigurationINTEL(VkDevice device,
 
 VkResult DispatchDevice::QueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) {
     if (!wrap_handles) return device_dispatch_table.QueueSetPerformanceConfigurationINTEL(queue, configuration);
-    { configuration = Unwrap(configuration); }
+    {
+        configuration = Unwrap(configuration);
+    }
     VkResult result = device_dispatch_table.QueueSetPerformanceConfigurationINTEL(queue, configuration);
 
     return result;
@@ -6979,7 +7177,9 @@ VkResult DispatchDevice::GetPerformanceParameterINTEL(VkDevice device, VkPerform
 
 void DispatchDevice::SetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) {
     if (!wrap_handles) return device_dispatch_table.SetLocalDimmingAMD(device, swapChain, localDimmingEnable);
-    { swapChain = Unwrap(swapChain); }
+    {
+        swapChain = Unwrap(swapChain);
+    }
     device_dispatch_table.SetLocalDimmingAMD(device, swapChain, localDimmingEnable);
 }
 #ifdef VK_USE_PLATFORM_FUCHSIA
@@ -7072,7 +7272,9 @@ VkResult DispatchInstance::GetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDe
 
 VkResult DispatchDevice::AcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) {
     if (!wrap_handles) return device_dispatch_table.AcquireFullScreenExclusiveModeEXT(device, swapchain);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     VkResult result = device_dispatch_table.AcquireFullScreenExclusiveModeEXT(device, swapchain);
 
     return result;
@@ -7080,7 +7282,9 @@ VkResult DispatchDevice::AcquireFullScreenExclusiveModeEXT(VkDevice device, VkSw
 
 VkResult DispatchDevice::ReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) {
     if (!wrap_handles) return device_dispatch_table.ReleaseFullScreenExclusiveModeEXT(device, swapchain);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     VkResult result = device_dispatch_table.ReleaseFullScreenExclusiveModeEXT(device, swapchain);
 
     return result;
@@ -7125,7 +7329,9 @@ void DispatchDevice::CmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_
 
 void DispatchDevice::ResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
     if (!wrap_handles) return device_dispatch_table.ResetQueryPoolEXT(device, queryPool, firstQuery, queryCount);
-    { queryPool = Unwrap(queryPool); }
+    {
+        queryPool = Unwrap(queryPool);
+    }
     device_dispatch_table.ResetQueryPoolEXT(device, queryPool, firstQuery, queryCount);
 }
 
@@ -7285,7 +7491,9 @@ VkResult DispatchDevice::TransitionImageLayoutEXT(VkDevice device, uint32_t tran
 void DispatchDevice::GetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource,
                                                    VkSubresourceLayout2* pLayout) {
     if (!wrap_handles) return device_dispatch_table.GetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout);
-    { image = Unwrap(image); }
+    {
+        image = Unwrap(image);
+    }
     device_dispatch_table.GetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout);
 }
 
@@ -7417,7 +7625,9 @@ void DispatchDevice::CmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer,
                                                   VkPipeline pipeline, uint32_t groupIndex) {
     if (!wrap_handles)
         return device_dispatch_table.CmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex);
-    { pipeline = Unwrap(pipeline); }
+    {
+        pipeline = Unwrap(pipeline);
+    }
     device_dispatch_table.CmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex);
 }
 
@@ -7463,7 +7673,9 @@ void DispatchDevice::CmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const Vk
 
 VkResult DispatchInstance::AcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) {
     if (!wrap_handles) return instance_dispatch_table.AcquireDrmDisplayEXT(physicalDevice, drmFd, display);
-    { display = Unwrap(display); }
+    {
+        display = Unwrap(display);
+    }
     VkResult result = instance_dispatch_table.AcquireDrmDisplayEXT(physicalDevice, drmFd, display);
 
     return result;
@@ -7544,7 +7756,9 @@ VkResult DispatchDevice::CreateCudaModuleNV(VkDevice device, const VkCudaModuleC
 
 VkResult DispatchDevice::GetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData) {
     if (!wrap_handles) return device_dispatch_table.GetCudaModuleCacheNV(device, module, pCacheSize, pCacheData);
-    { module = Unwrap(module); }
+    {
+        module = Unwrap(module);
+    }
     VkResult result = device_dispatch_table.GetCudaModuleCacheNV(device, module, pCacheSize, pCacheData);
 
     return result;
@@ -7618,14 +7832,18 @@ void DispatchDevice::CmdEndPerTileExecutionQCOM(VkCommandBuffer commandBuffer, c
 void DispatchDevice::GetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout,
                                                    VkDeviceSize* pLayoutSizeInBytes) {
     if (!wrap_handles) return device_dispatch_table.GetDescriptorSetLayoutSizeEXT(device, layout, pLayoutSizeInBytes);
-    { layout = Unwrap(layout); }
+    {
+        layout = Unwrap(layout);
+    }
     device_dispatch_table.GetDescriptorSetLayoutSizeEXT(device, layout, pLayoutSizeInBytes);
 }
 
 void DispatchDevice::GetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding,
                                                             VkDeviceSize* pOffset) {
     if (!wrap_handles) return device_dispatch_table.GetDescriptorSetLayoutBindingOffsetEXT(device, layout, binding, pOffset);
-    { layout = Unwrap(layout); }
+    {
+        layout = Unwrap(layout);
+    }
     device_dispatch_table.GetDescriptorSetLayoutBindingOffsetEXT(device, layout, binding, pOffset);
 }
 
@@ -7654,7 +7872,9 @@ void DispatchDevice::CmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuf
     if (!wrap_handles)
         return device_dispatch_table.CmdSetDescriptorBufferOffsetsEXT(commandBuffer, pipelineBindPoint, layout, firstSet, setCount,
                                                                       pBufferIndices, pOffsets);
-    { layout = Unwrap(layout); }
+    {
+        layout = Unwrap(layout);
+    }
     device_dispatch_table.CmdSetDescriptorBufferOffsetsEXT(commandBuffer, pipelineBindPoint, layout, firstSet, setCount,
                                                            pBufferIndices, pOffsets);
 }
@@ -7664,7 +7884,9 @@ void DispatchDevice::CmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer
                                                                 uint32_t set) {
     if (!wrap_handles)
         return device_dispatch_table.CmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer, pipelineBindPoint, layout, set);
-    { layout = Unwrap(layout); }
+    {
+        layout = Unwrap(layout);
+    }
     device_dispatch_table.CmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer, pipelineBindPoint, layout, set);
 }
 
@@ -7792,7 +8014,9 @@ VkResult DispatchDevice::GetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCou
 
 VkResult DispatchInstance::AcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
     if (!wrap_handles) return instance_dispatch_table.AcquireWinrtDisplayNV(physicalDevice, display);
-    { display = Unwrap(display); }
+    {
+        display = Unwrap(display);
+    }
     VkResult result = instance_dispatch_table.AcquireWinrtDisplayNV(physicalDevice, display);
 
     return result;
@@ -7929,7 +8153,9 @@ VkResult DispatchDevice::SetBufferCollectionImageConstraintsFUCHSIA(VkDevice dev
                                                                     const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) {
     if (!wrap_handles)
         return device_dispatch_table.SetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo);
-    { collection = Unwrap(collection); }
+    {
+        collection = Unwrap(collection);
+    }
     VkResult result = device_dispatch_table.SetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo);
 
     return result;
@@ -7939,7 +8165,9 @@ VkResult DispatchDevice::SetBufferCollectionBufferConstraintsFUCHSIA(VkDevice de
                                                                      const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
     if (!wrap_handles)
         return device_dispatch_table.SetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo);
-    { collection = Unwrap(collection); }
+    {
+        collection = Unwrap(collection);
+    }
     VkResult result = device_dispatch_table.SetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo);
 
     return result;
@@ -7955,7 +8183,9 @@ void DispatchDevice::DestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCol
 VkResult DispatchDevice::GetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection,
                                                               VkBufferCollectionPropertiesFUCHSIA* pProperties) {
     if (!wrap_handles) return device_dispatch_table.GetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties);
-    { collection = Unwrap(collection); }
+    {
+        collection = Unwrap(collection);
+    }
     VkResult result = device_dispatch_table.GetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties);
 
     return result;
@@ -7966,7 +8196,9 @@ VkResult DispatchDevice::GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice
                                                                        VkExtent2D* pMaxWorkgroupSize) {
     if (!wrap_handles)
         return device_dispatch_table.GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize);
-    { renderpass = Unwrap(renderpass); }
+    {
+        renderpass = Unwrap(renderpass);
+    }
     VkResult result = device_dispatch_table.GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize);
 
     return result;
@@ -7978,7 +8210,9 @@ void DispatchDevice::CmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) {
 
 void DispatchDevice::CmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) {
     if (!wrap_handles) return device_dispatch_table.CmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout);
-    { imageView = Unwrap(imageView); }
+    {
+        imageView = Unwrap(imageView);
+    }
     device_dispatch_table.CmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout);
 }
 
@@ -8559,13 +8793,17 @@ void DispatchDevice::CmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_
 
 void DispatchDevice::CmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
     if (!wrap_handles) return device_dispatch_table.CmdDrawClusterIndirectHUAWEI(commandBuffer, buffer, offset);
-    { buffer = Unwrap(buffer); }
+    {
+        buffer = Unwrap(buffer);
+    }
     device_dispatch_table.CmdDrawClusterIndirectHUAWEI(commandBuffer, buffer, offset);
 }
 
 void DispatchDevice::SetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) {
     if (!wrap_handles) return device_dispatch_table.SetDeviceMemoryPriorityEXT(device, memory, priority);
-    { memory = Unwrap(memory); }
+    {
+        memory = Unwrap(memory);
+    }
     device_dispatch_table.SetDeviceMemoryPriorityEXT(device, memory, priority);
 }
 
@@ -8597,7 +8835,9 @@ void DispatchDevice::GetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device,
 
 void DispatchDevice::GetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData) {
     if (!wrap_handles) return device_dispatch_table.GetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData);
-    { descriptorSet = Unwrap(descriptorSet); }
+    {
+        descriptorSet = Unwrap(descriptorSet);
+    }
     device_dispatch_table.GetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData);
 }
 
@@ -8613,7 +8853,9 @@ void DispatchDevice::CmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffe
     if (!wrap_handles)
         return device_dispatch_table.CmdCopyMemoryToImageIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride, dstImage,
                                                                     dstImageLayout, pImageSubresources);
-    { dstImage = Unwrap(dstImage); }
+    {
+        dstImage = Unwrap(dstImage);
+    }
     device_dispatch_table.CmdCopyMemoryToImageIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride, dstImage,
                                                          dstImageLayout, pImageSubresources);
 }
@@ -8661,7 +8903,9 @@ void DispatchDevice::GetPipelineIndirectMemoryRequirementsNV(VkDevice device, co
 void DispatchDevice::CmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
                                                        VkPipeline pipeline) {
     if (!wrap_handles) return device_dispatch_table.CmdUpdatePipelineIndirectBufferNV(commandBuffer, pipelineBindPoint, pipeline);
-    { pipeline = Unwrap(pipeline); }
+    {
+        pipeline = Unwrap(pipeline);
+    }
     device_dispatch_table.CmdUpdatePipelineIndirectBufferNV(commandBuffer, pipelineBindPoint, pipeline);
 }
 
@@ -9021,7 +9265,9 @@ VkResult DispatchDevice::GetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice de
 void DispatchDevice::GetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule,
                                                   VkShaderModuleIdentifierEXT* pIdentifier) {
     if (!wrap_handles) return device_dispatch_table.GetShaderModuleIdentifierEXT(device, shaderModule, pIdentifier);
-    { shaderModule = Unwrap(shaderModule); }
+    {
+        shaderModule = Unwrap(shaderModule);
+    }
     device_dispatch_table.GetShaderModuleIdentifierEXT(device, shaderModule, pIdentifier);
 }
 
@@ -9084,7 +9330,9 @@ VkResult DispatchDevice::BindOpticalFlowSessionImageNV(VkDevice device, VkOptica
 void DispatchDevice::CmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session,
                                              const VkOpticalFlowExecuteInfoNV* pExecuteInfo) {
     if (!wrap_handles) return device_dispatch_table.CmdOpticalFlowExecuteNV(commandBuffer, session, pExecuteInfo);
-    { session = Unwrap(session); }
+    {
+        session = Unwrap(session);
+    }
     device_dispatch_table.CmdOpticalFlowExecuteNV(commandBuffer, session, pExecuteInfo);
 }
 
@@ -9100,7 +9348,9 @@ void DispatchDevice::DestroyShaderEXT(VkDevice device, VkShaderEXT shader, const
 
 VkResult DispatchDevice::GetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) {
     if (!wrap_handles) return device_dispatch_table.GetShaderBinaryDataEXT(device, shader, pDataSize, pData);
-    { shader = Unwrap(shader); }
+    {
+        shader = Unwrap(shader);
+    }
     VkResult result = device_dispatch_table.GetShaderBinaryDataEXT(device, shader, pDataSize, pData);
 
     return result;
@@ -9132,7 +9382,9 @@ VkResult DispatchDevice::GetFramebufferTilePropertiesQCOM(VkDevice device, VkFra
                                                           VkTilePropertiesQCOM* pProperties) {
     if (!wrap_handles)
         return device_dispatch_table.GetFramebufferTilePropertiesQCOM(device, framebuffer, pPropertiesCount, pProperties);
-    { framebuffer = Unwrap(framebuffer); }
+    {
+        framebuffer = Unwrap(framebuffer);
+    }
     VkResult result = device_dispatch_table.GetFramebufferTilePropertiesQCOM(device, framebuffer, pPropertiesCount, pProperties);
 
     return result;
@@ -9229,7 +9481,9 @@ void DispatchDevice::CmdConvertCooperativeVectorMatrixNV(VkCommandBuffer command
 VkResult DispatchDevice::SetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain,
                                                const VkLatencySleepModeInfoNV* pSleepModeInfo) {
     if (!wrap_handles) return device_dispatch_table.SetLatencySleepModeNV(device, swapchain, pSleepModeInfo);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     VkResult result = device_dispatch_table.SetLatencySleepModeNV(device, swapchain, pSleepModeInfo);
 
     return result;
@@ -9258,13 +9512,17 @@ VkResult DispatchDevice::LatencySleepNV(VkDevice device, VkSwapchainKHR swapchai
 void DispatchDevice::SetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain,
                                         const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) {
     if (!wrap_handles) return device_dispatch_table.SetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     device_dispatch_table.SetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo);
 }
 
 void DispatchDevice::GetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) {
     if (!wrap_handles) return device_dispatch_table.GetLatencyTimingsNV(device, swapchain, pLatencyMarkerInfo);
-    { swapchain = Unwrap(swapchain); }
+    {
+        swapchain = Unwrap(swapchain);
+    }
     device_dispatch_table.GetLatencyTimingsNV(device, swapchain, pLatencyMarkerInfo);
 }
 
@@ -9379,7 +9637,9 @@ void DispatchDevice::DestroyDataGraphPipelineSessionARM(VkDevice device, VkDataG
 void DispatchDevice::CmdDispatchDataGraphARM(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session,
                                              const VkDataGraphPipelineDispatchInfoARM* pInfo) {
     if (!wrap_handles) return device_dispatch_table.CmdDispatchDataGraphARM(commandBuffer, session, pInfo);
-    { session = Unwrap(session); }
+    {
+        session = Unwrap(session);
+    }
     device_dispatch_table.CmdDispatchDataGraphARM(commandBuffer, session, pInfo);
 }
 
@@ -9800,7 +10060,9 @@ void DispatchDevice::DestroyShaderInstrumentationARM(VkDevice device, VkShaderIn
 
 void DispatchDevice::CmdBeginShaderInstrumentationARM(VkCommandBuffer commandBuffer, VkShaderInstrumentationARM instrumentation) {
     if (!wrap_handles) return device_dispatch_table.CmdBeginShaderInstrumentationARM(commandBuffer, instrumentation);
-    { instrumentation = Unwrap(instrumentation); }
+    {
+        instrumentation = Unwrap(instrumentation);
+    }
     device_dispatch_table.CmdBeginShaderInstrumentationARM(commandBuffer, instrumentation);
 }
 
@@ -9814,7 +10076,9 @@ VkResult DispatchDevice::GetShaderInstrumentationValuesARM(VkDevice device, VkSh
     if (!wrap_handles)
         return device_dispatch_table.GetShaderInstrumentationValuesARM(device, instrumentation, pMetricBlockCount, pMetricValues,
                                                                        flags);
-    { instrumentation = Unwrap(instrumentation); }
+    {
+        instrumentation = Unwrap(instrumentation);
+    }
     VkResult result =
         device_dispatch_table.GetShaderInstrumentationValuesARM(device, instrumentation, pMetricBlockCount, pMetricValues, flags);
 
@@ -9823,7 +10087,9 @@ VkResult DispatchDevice::GetShaderInstrumentationValuesARM(VkDevice device, VkSh
 
 void DispatchDevice::ClearShaderInstrumentationMetricsARM(VkDevice device, VkShaderInstrumentationARM instrumentation) {
     if (!wrap_handles) return device_dispatch_table.ClearShaderInstrumentationMetricsARM(device, instrumentation);
-    { instrumentation = Unwrap(instrumentation); }
+    {
+        instrumentation = Unwrap(instrumentation);
+    }
     device_dispatch_table.ClearShaderInstrumentationMetricsARM(device, instrumentation);
 }
 
@@ -10186,7 +10452,9 @@ VkResult DispatchDevice::GetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevic
     if (!wrap_handles)
         return device_dispatch_table.GetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount,
                                                                                      dataSize, pData);
-    { pipeline = Unwrap(pipeline); }
+    {
+        pipeline = Unwrap(pipeline);
+    }
     VkResult result = device_dispatch_table.GetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup,
                                                                                             groupCount, dataSize, pData);
 
@@ -10206,7 +10474,9 @@ void DispatchDevice::CmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer,
 VkDeviceSize DispatchDevice::GetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group,
                                                                   VkShaderGroupShaderKHR groupShader) {
     if (!wrap_handles) return device_dispatch_table.GetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader);
-    { pipeline = Unwrap(pipeline); }
+    {
+        pipeline = Unwrap(pipeline);
+    }
     VkDeviceSize result = device_dispatch_table.GetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader);
 
     return result;
@@ -10224,7 +10494,9 @@ void DispatchDevice::CmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t
 void DispatchDevice::CmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                                  uint32_t drawCount, uint32_t stride) {
     if (!wrap_handles) return device_dispatch_table.CmdDrawMeshTasksIndirectEXT(commandBuffer, buffer, offset, drawCount, stride);
-    { buffer = Unwrap(buffer); }
+    {
+        buffer = Unwrap(buffer);
+    }
     device_dispatch_table.CmdDrawMeshTasksIndirectEXT(commandBuffer, buffer, offset, drawCount, stride);
 }
 
diff --git a/layers/vulkansc/generated/feature_not_present.cpp b/layers/vulkansc/generated/feature_not_present.cpp
index 88c4e3d45..9b334285b 100644
--- a/layers/vulkansc/generated/feature_not_present.cpp
+++ b/layers/vulkansc/generated/feature_not_present.cpp
@@ -25,14 +25,14 @@
 
 namespace vvl {
 
-void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const VkDeviceCreateInfo &create_info) {
+void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const VkDeviceCreateInfo& create_info) {
     std::ostringstream ss;
     ss << "returned VK_ERROR_FEATURE_NOT_PRESENT because the following features were not supported on this physical device:\n";
 
     // First do 1.0 VkPhysicalDeviceFeatures
-    const auto *features2_in = vku::FindStructInPNextChain<VkPhysicalDeviceFeatures2>(create_info.pNext);
+    const auto* features2_in = vku::FindStructInPNextChain<VkPhysicalDeviceFeatures2>(create_info.pNext);
     if (create_info.pEnabledFeatures || features2_in) {
-        const VkPhysicalDeviceFeatures &enabling =
+        const VkPhysicalDeviceFeatures& enabling =
             create_info.pEnabledFeatures ? *create_info.pEnabledFeatures : features2_in->features;
 
         VkPhysicalDeviceFeatures supported = {};
@@ -204,15 +204,15 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
         }
     }
     VkPhysicalDeviceFeatures2 features_2 = vku::InitStructHelper();
-    for (const VkBaseInStructure *current = static_cast<const VkBaseInStructure *>(create_info.pNext); current != nullptr;
+    for (const VkBaseInStructure* current = static_cast<const VkBaseInStructure*>(create_info.pNext); current != nullptr;
          current = current->pNext) {
         switch (current->sType) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
                 VkPhysicalDevice16BitStorageFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevice16BitStorageFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures *>(current);
+                const VkPhysicalDevice16BitStorageFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(current);
                 if (enabling->storageBuffer16BitAccess && !supported.storageBuffer16BitAccess) {
                     ss << "VkPhysicalDevice16BitStorageFeatures::storageBuffer16BitAccess is not supported\n";
                 }
@@ -231,8 +231,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevice4444FormatsFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevice4444FormatsFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT *>(current);
+                const VkPhysicalDevice4444FormatsFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(current);
                 if (enabling->formatA4R4G4B4 && !supported.formatA4R4G4B4) {
                     ss << "VkPhysicalDevice4444FormatsFeaturesEXT::formatA4R4G4B4 is not supported\n";
                 }
@@ -245,8 +245,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevice8BitStorageFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevice8BitStorageFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures *>(current);
+                const VkPhysicalDevice8BitStorageFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(current);
                 if (enabling->storageBuffer8BitAccess && !supported.storageBuffer8BitAccess) {
                     ss << "VkPhysicalDevice8BitStorageFeatures::storageBuffer8BitAccess is not supported\n";
                 }
@@ -262,8 +262,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceASTCDecodeFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceASTCDecodeFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT *>(current);
+                const VkPhysicalDeviceASTCDecodeFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(current);
                 if (enabling->decodeModeSharedExponent && !supported.decodeModeSharedExponent) {
                     ss << "VkPhysicalDeviceASTCDecodeFeaturesEXT::decodeModeSharedExponent is not supported\n";
                 }
@@ -273,8 +273,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceAccelerationStructureFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceAccelerationStructureFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(current);
+                const VkPhysicalDeviceAccelerationStructureFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(current);
                 if (enabling->accelerationStructure && !supported.accelerationStructure) {
                     ss << "VkPhysicalDeviceAccelerationStructureFeaturesKHR::accelerationStructure is not supported\n";
                 }
@@ -298,8 +298,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceAddressBindingReportFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceAddressBindingReportFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT *>(current);
+                const VkPhysicalDeviceAddressBindingReportFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(current);
                 if (enabling->reportAddressBinding && !supported.reportAddressBinding) {
                     ss << "VkPhysicalDeviceAddressBindingReportFeaturesEXT::reportAddressBinding is not supported\n";
                 }
@@ -309,8 +309,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceAmigoProfilingFeaturesSEC supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceAmigoProfilingFeaturesSEC *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC *>(current);
+                const VkPhysicalDeviceAmigoProfilingFeaturesSEC* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(current);
                 if (enabling->amigoProfiling && !supported.amigoProfiling) {
                     ss << "VkPhysicalDeviceAmigoProfilingFeaturesSEC::amigoProfiling is not supported\n";
                 }
@@ -320,8 +320,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceAntiLagFeaturesAMD supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceAntiLagFeaturesAMD *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD *>(current);
+                const VkPhysicalDeviceAntiLagFeaturesAMD* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD*>(current);
                 if (enabling->antiLag && !supported.antiLag) {
                     ss << "VkPhysicalDeviceAntiLagFeaturesAMD::antiLag is not supported\n";
                 }
@@ -331,8 +331,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *>(current);
+                const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(current);
                 if (enabling->attachmentFeedbackLoopDynamicState && !supported.attachmentFeedbackLoopDynamicState) {
                     ss << "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::attachmentFeedbackLoopDynamicState is "
                           "not supported\n";
@@ -343,8 +343,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *>(current);
+                const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(current);
                 if (enabling->attachmentFeedbackLoopLayout && !supported.attachmentFeedbackLoopLayout) {
                     ss << "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::attachmentFeedbackLoopLayout is not "
                           "supported\n";
@@ -355,8 +355,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(current);
+                const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(current);
                 if (enabling->advancedBlendCoherentOperations && !supported.advancedBlendCoherentOperations) {
                     ss << "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::advancedBlendCoherentOperations is not supported\n";
                 }
@@ -366,8 +366,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceBorderColorSwizzleFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>(current);
+                const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(current);
                 if (enabling->borderColorSwizzle && !supported.borderColorSwizzle) {
                     ss << "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::borderColorSwizzle is not supported\n";
                 }
@@ -380,8 +380,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceBufferDeviceAddressFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceBufferDeviceAddressFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures *>(current);
+                const VkPhysicalDeviceBufferDeviceAddressFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(current);
                 if (enabling->bufferDeviceAddress && !supported.bufferDeviceAddress) {
                     ss << "VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress is not supported\n";
                 }
@@ -397,8 +397,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceBufferDeviceAddressFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(current);
+                const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(current);
                 if (enabling->bufferDeviceAddress && !supported.bufferDeviceAddress) {
                     ss << "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::bufferDeviceAddress is not supported\n";
                 }
@@ -414,8 +414,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceClusterAccelerationStructureFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *>(current);
+                const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*>(current);
                 if (enabling->clusterAccelerationStructure && !supported.clusterAccelerationStructure) {
                     ss << "VkPhysicalDeviceClusterAccelerationStructureFeaturesNV::clusterAccelerationStructure is not supported\n";
                 }
@@ -425,8 +425,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *>(current);
+                const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(current);
                 if (enabling->clustercullingShader && !supported.clustercullingShader) {
                     ss << "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::clustercullingShader is not supported\n";
                 }
@@ -439,8 +439,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCoherentMemoryFeaturesAMD supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCoherentMemoryFeaturesAMD *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(current);
+                const VkPhysicalDeviceCoherentMemoryFeaturesAMD* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(current);
                 if (enabling->deviceCoherentMemory && !supported.deviceCoherentMemory) {
                     ss << "VkPhysicalDeviceCoherentMemoryFeaturesAMD::deviceCoherentMemory is not supported\n";
                 }
@@ -450,8 +450,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceColorWriteEnableFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceColorWriteEnableFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT *>(current);
+                const VkPhysicalDeviceColorWriteEnableFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(current);
                 if (enabling->colorWriteEnable && !supported.colorWriteEnable) {
                     ss << "VkPhysicalDeviceColorWriteEnableFeaturesEXT::colorWriteEnable is not supported\n";
                 }
@@ -461,8 +461,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCommandBufferInheritanceFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *>(current);
+                const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV*>(current);
                 if (enabling->commandBufferInheritance && !supported.commandBufferInheritance) {
                     ss << "VkPhysicalDeviceCommandBufferInheritanceFeaturesNV::commandBufferInheritance is not supported\n";
                 }
@@ -472,8 +472,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV *>(current);
+                const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV*>(current);
                 if (enabling->computeOccupancyPriority && !supported.computeOccupancyPriority) {
                     ss << "VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV::computeOccupancyPriority is not supported\n";
                 }
@@ -483,8 +483,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *>(current);
+                const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*>(current);
                 if (enabling->computeDerivativeGroupQuads && !supported.computeDerivativeGroupQuads) {
                     ss << "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::computeDerivativeGroupQuads is not supported\n";
                 }
@@ -497,8 +497,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceConditionalRenderingFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceConditionalRenderingFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(current);
+                const VkPhysicalDeviceConditionalRenderingFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(current);
                 if (enabling->conditionalRendering && !supported.conditionalRendering) {
                     ss << "VkPhysicalDeviceConditionalRenderingFeaturesEXT::conditionalRendering is not supported\n";
                 }
@@ -511,8 +511,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCooperativeMatrix2FeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(current);
+                const VkPhysicalDeviceCooperativeMatrix2FeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(current);
                 if (enabling->cooperativeMatrixWorkgroupScope && !supported.cooperativeMatrixWorkgroupScope) {
                     ss << "VkPhysicalDeviceCooperativeMatrix2FeaturesNV::cooperativeMatrixWorkgroupScope is not supported\n";
                 }
@@ -540,8 +540,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM *>(current);
+                const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*>(current);
                 if (enabling->cooperativeMatrixConversion && !supported.cooperativeMatrixConversion) {
                     ss << "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM::cooperativeMatrixConversion is not supported\n";
                 }
@@ -551,8 +551,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV *>(current);
+                const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV*>(current);
                 if (enabling->cooperativeMatrixDecodeVector && !supported.cooperativeMatrixDecodeVector) {
                     ss << "VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV::cooperativeMatrixDecodeVector is not "
                           "supported\n";
@@ -563,8 +563,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCooperativeMatrixFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(current);
+                const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR*>(current);
                 if (enabling->cooperativeMatrix && !supported.cooperativeMatrix) {
                     ss << "VkPhysicalDeviceCooperativeMatrixFeaturesKHR::cooperativeMatrix is not supported\n";
                 }
@@ -577,8 +577,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCooperativeMatrixFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCooperativeMatrixFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(current);
+                const VkPhysicalDeviceCooperativeMatrixFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(current);
                 if (enabling->cooperativeMatrix && !supported.cooperativeMatrix) {
                     ss << "VkPhysicalDeviceCooperativeMatrixFeaturesNV::cooperativeMatrix is not supported\n";
                 }
@@ -591,8 +591,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCooperativeVectorFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCooperativeVectorFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV *>(current);
+                const VkPhysicalDeviceCooperativeVectorFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV*>(current);
                 if (enabling->cooperativeVector && !supported.cooperativeVector) {
                     ss << "VkPhysicalDeviceCooperativeVectorFeaturesNV::cooperativeVector is not supported\n";
                 }
@@ -605,8 +605,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *>(current);
+                const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR*>(current);
                 if (enabling->indirectMemoryCopy && !supported.indirectMemoryCopy) {
                     ss << "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR::indirectMemoryCopy is not supported\n";
                 }
@@ -619,8 +619,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCopyMemoryIndirectFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *>(current);
+                const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(current);
                 if (enabling->indirectCopy && !supported.indirectCopy) {
                     ss << "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::indirectCopy is not supported\n";
                 }
@@ -630,8 +630,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCornerSampledImageFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCornerSampledImageFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV *>(current);
+                const VkPhysicalDeviceCornerSampledImageFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(current);
                 if (enabling->cornerSampledImage && !supported.cornerSampledImage) {
                     ss << "VkPhysicalDeviceCornerSampledImageFeaturesNV::cornerSampledImage is not supported\n";
                 }
@@ -641,8 +641,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCoverageReductionModeFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCoverageReductionModeFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(current);
+                const VkPhysicalDeviceCoverageReductionModeFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(current);
                 if (enabling->coverageReductionMode && !supported.coverageReductionMode) {
                     ss << "VkPhysicalDeviceCoverageReductionModeFeaturesNV::coverageReductionMode is not supported\n";
                 }
@@ -652,8 +652,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCubicClampFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCubicClampFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCubicClampFeaturesQCOM *>(current);
+                const VkPhysicalDeviceCubicClampFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCubicClampFeaturesQCOM*>(current);
                 if (enabling->cubicRangeClamp && !supported.cubicRangeClamp) {
                     ss << "VkPhysicalDeviceCubicClampFeaturesQCOM::cubicRangeClamp is not supported\n";
                 }
@@ -663,8 +663,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCubicWeightsFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCubicWeightsFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM *>(current);
+                const VkPhysicalDeviceCubicWeightsFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM*>(current);
                 if (enabling->selectableCubicWeights && !supported.selectableCubicWeights) {
                     ss << "VkPhysicalDeviceCubicWeightsFeaturesQCOM::selectableCubicWeights is not supported\n";
                 }
@@ -675,8 +675,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCudaKernelLaunchFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCudaKernelLaunchFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV *>(current);
+                const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV*>(current);
                 if (enabling->cudaKernelLaunchFeatures && !supported.cudaKernelLaunchFeatures) {
                     ss << "VkPhysicalDeviceCudaKernelLaunchFeaturesNV::cudaKernelLaunchFeatures is not supported\n";
                 }
@@ -687,8 +687,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCustomBorderColorFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCustomBorderColorFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(current);
+                const VkPhysicalDeviceCustomBorderColorFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(current);
                 if (enabling->customBorderColors && !supported.customBorderColors) {
                     ss << "VkPhysicalDeviceCustomBorderColorFeaturesEXT::customBorderColors is not supported\n";
                 }
@@ -701,8 +701,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceCustomResolveFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceCustomResolveFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceCustomResolveFeaturesEXT *>(current);
+                const VkPhysicalDeviceCustomResolveFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceCustomResolveFeaturesEXT*>(current);
                 if (enabling->customResolve && !supported.customResolve) {
                     ss << "VkPhysicalDeviceCustomResolveFeaturesEXT::customResolve is not supported\n";
                 }
@@ -712,8 +712,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDataGraphFeaturesARM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDataGraphFeaturesARM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDataGraphFeaturesARM *>(current);
+                const VkPhysicalDeviceDataGraphFeaturesARM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDataGraphFeaturesARM*>(current);
                 if (enabling->dataGraph && !supported.dataGraph) {
                     ss << "VkPhysicalDeviceDataGraphFeaturesARM::dataGraph is not supported\n";
                 }
@@ -735,8 +735,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDataGraphModelFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDataGraphModelFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM *>(current);
+                const VkPhysicalDeviceDataGraphModelFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM*>(current);
                 if (enabling->dataGraphModel && !supported.dataGraphModel) {
                     ss << "VkPhysicalDeviceDataGraphModelFeaturesQCOM::dataGraphModel is not supported\n";
                 }
@@ -746,8 +746,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM *>(current);
+                const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM*>(current);
                 if (enabling->dataGraphNeuralAcceleratorStatistics && !supported.dataGraphNeuralAcceleratorStatistics) {
                     ss << "VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM::dataGraphNeuralAcceleratorStatistics "
                           "is not supported\n";
@@ -758,8 +758,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM *>(current);
+                const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM*>(current);
                 if (enabling->dataGraphOpticalFlow && !supported.dataGraphOpticalFlow) {
                     ss << "VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM::dataGraphOpticalFlow is not supported\n";
                 }
@@ -769,8 +769,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(current);
+                const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(current);
                 if (enabling->dedicatedAllocationImageAliasing && !supported.dedicatedAllocationImageAliasing) {
                     ss << "VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::dedicatedAllocationImageAliasing is not "
                           "supported\n";
@@ -782,8 +782,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX *>(current);
+                const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX*>(current);
                 if (enabling->denseGeometryFormat && !supported.denseGeometryFormat) {
                     ss << "VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX::denseGeometryFormat is not supported\n";
                 }
@@ -794,8 +794,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDepthBiasControlFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDepthBiasControlFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT *>(current);
+                const VkPhysicalDeviceDepthBiasControlFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(current);
                 if (enabling->depthBiasControl && !supported.depthBiasControl) {
                     ss << "VkPhysicalDeviceDepthBiasControlFeaturesEXT::depthBiasControl is not supported\n";
                 }
@@ -816,8 +816,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDepthClampControlFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDepthClampControlFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDepthClampControlFeaturesEXT *>(current);
+                const VkPhysicalDeviceDepthClampControlFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDepthClampControlFeaturesEXT*>(current);
                 if (enabling->depthClampControl && !supported.depthClampControl) {
                     ss << "VkPhysicalDeviceDepthClampControlFeaturesEXT::depthClampControl is not supported\n";
                 }
@@ -827,8 +827,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDepthClampZeroOneFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *>(current);
+                const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*>(current);
                 if (enabling->depthClampZeroOne && !supported.depthClampZeroOne) {
                     ss << "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR::depthClampZeroOne is not supported\n";
                 }
@@ -838,8 +838,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDepthClipControlFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDepthClipControlFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT *>(current);
+                const VkPhysicalDeviceDepthClipControlFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(current);
                 if (enabling->depthClipControl && !supported.depthClipControl) {
                     ss << "VkPhysicalDeviceDepthClipControlFeaturesEXT::depthClipControl is not supported\n";
                 }
@@ -849,8 +849,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDepthClipEnableFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDepthClipEnableFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(current);
+                const VkPhysicalDeviceDepthClipEnableFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(current);
                 if (enabling->depthClipEnable && !supported.depthClipEnable) {
                     ss << "VkPhysicalDeviceDepthClipEnableFeaturesEXT::depthClipEnable is not supported\n";
                 }
@@ -860,8 +860,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDescriptorBufferFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDescriptorBufferFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT *>(current);
+                const VkPhysicalDeviceDescriptorBufferFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(current);
                 if (enabling->descriptorBuffer && !supported.descriptorBuffer) {
                     ss << "VkPhysicalDeviceDescriptorBufferFeaturesEXT::descriptorBuffer is not supported\n";
                 }
@@ -880,8 +880,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDescriptorBufferTensorFeaturesARM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *>(current);
+                const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM*>(current);
                 if (enabling->descriptorBufferTensorDescriptors && !supported.descriptorBufferTensorDescriptors) {
                     ss << "VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::descriptorBufferTensorDescriptors is not supported\n";
                 }
@@ -891,8 +891,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDescriptorHeapFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDescriptorHeapFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDescriptorHeapFeaturesEXT *>(current);
+                const VkPhysicalDeviceDescriptorHeapFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDescriptorHeapFeaturesEXT*>(current);
                 if (enabling->descriptorHeap && !supported.descriptorHeap) {
                     ss << "VkPhysicalDeviceDescriptorHeapFeaturesEXT::descriptorHeap is not supported\n";
                 }
@@ -905,8 +905,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDescriptorIndexingFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDescriptorIndexingFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures *>(current);
+                const VkPhysicalDeviceDescriptorIndexingFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(current);
                 if (enabling->shaderInputAttachmentArrayDynamicIndexing && !supported.shaderInputAttachmentArrayDynamicIndexing) {
                     ss << "VkPhysicalDeviceDescriptorIndexingFeatures::shaderInputAttachmentArrayDynamicIndexing is not "
                           "supported\n";
@@ -1001,8 +1001,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(current);
+                const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*>(current);
                 if (enabling->descriptorPoolOverallocation && !supported.descriptorPoolOverallocation) {
                     ss << "VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::descriptorPoolOverallocation is not supported\n";
                 }
@@ -1012,8 +1012,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *>(current);
+                const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(current);
                 if (enabling->descriptorSetHostMapping && !supported.descriptorSetHostMapping) {
                     ss << "VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::descriptorSetHostMapping is not supported\n";
                 }
@@ -1023,8 +1023,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR *>(current);
+                const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR*>(current);
                 if (enabling->deviceAddressCommands && !supported.deviceAddressCommands) {
                     ss << "VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR::deviceAddressCommands is not supported\n";
                 }
@@ -1034,8 +1034,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *>(current);
+                const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(current);
                 if (enabling->deviceGeneratedCompute && !supported.deviceGeneratedCompute) {
                     ss << "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::deviceGeneratedCompute is not supported\n";
                 }
@@ -1053,8 +1053,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *>(current);
+                const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*>(current);
                 if (enabling->deviceGeneratedCommands && !supported.deviceGeneratedCommands) {
                     ss << "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::deviceGeneratedCommands is not supported\n";
                 }
@@ -1067,8 +1067,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>(current);
+                const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(current);
                 if (enabling->deviceGeneratedCommands && !supported.deviceGeneratedCommands) {
                     ss << "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::deviceGeneratedCommands is not supported\n";
                 }
@@ -1078,8 +1078,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDeviceMemoryReportFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(current);
+                const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(current);
                 if (enabling->deviceMemoryReport && !supported.deviceMemoryReport) {
                     ss << "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::deviceMemoryReport is not supported\n";
                 }
@@ -1089,8 +1089,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDiagnosticsConfigFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>(current);
+                const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(current);
                 if (enabling->diagnosticsConfig && !supported.diagnosticsConfig) {
                     ss << "VkPhysicalDeviceDiagnosticsConfigFeaturesNV::diagnosticsConfig is not supported\n";
                 }
@@ -1101,8 +1101,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDisplacementMicromapFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDisplacementMicromapFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV *>(current);
+                const VkPhysicalDeviceDisplacementMicromapFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(current);
                 if (enabling->displacementMicromap && !supported.displacementMicromap) {
                     ss << "VkPhysicalDeviceDisplacementMicromapFeaturesNV::displacementMicromap is not supported\n";
                 }
@@ -1113,8 +1113,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDynamicRenderingFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDynamicRenderingFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures *>(current);
+                const VkPhysicalDeviceDynamicRenderingFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(current);
                 if (enabling->dynamicRendering && !supported.dynamicRendering) {
                     ss << "VkPhysicalDeviceDynamicRenderingFeatures::dynamicRendering is not supported\n";
                 }
@@ -1124,8 +1124,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDynamicRenderingLocalReadFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *>(current);
+                const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(current);
                 if (enabling->dynamicRenderingLocalRead && !supported.dynamicRenderingLocalRead) {
                     ss << "VkPhysicalDeviceDynamicRenderingLocalReadFeatures::dynamicRenderingLocalRead is not supported\n";
                 }
@@ -1135,8 +1135,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *>(current);
+                const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*>(current);
                 if (enabling->dynamicRenderingUnusedAttachments && !supported.dynamicRenderingUnusedAttachments) {
                     ss << "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::dynamicRenderingUnusedAttachments is not "
                           "supported\n";
@@ -1147,8 +1147,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *>(current);
+                const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM*>(current);
                 if (enabling->elapsedTimerQuery && !supported.elapsedTimerQuery) {
                     ss << "VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM::elapsedTimerQuery is not supported\n";
                 }
@@ -1158,8 +1158,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceExclusiveScissorFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceExclusiveScissorFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV *>(current);
+                const VkPhysicalDeviceExclusiveScissorFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(current);
                 if (enabling->exclusiveScissor && !supported.exclusiveScissor) {
                     ss << "VkPhysicalDeviceExclusiveScissorFeaturesNV::exclusiveScissor is not supported\n";
                 }
@@ -1169,8 +1169,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceExtendedDynamicState2FeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>(current);
+                const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(current);
                 if (enabling->extendedDynamicState2 && !supported.extendedDynamicState2) {
                     ss << "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::extendedDynamicState2 is not supported\n";
                 }
@@ -1187,8 +1187,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceExtendedDynamicState3FeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(current);
+                const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(current);
                 if (enabling->extendedDynamicState3TessellationDomainOrigin &&
                     !supported.extendedDynamicState3TessellationDomainOrigin) {
                     ss << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::extendedDynamicState3TessellationDomainOrigin is not "
@@ -1327,8 +1327,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceExtendedDynamicStateFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(current);
+                const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(current);
                 if (enabling->extendedDynamicState && !supported.extendedDynamicState) {
                     ss << "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::extendedDynamicState is not supported\n";
                 }
@@ -1338,8 +1338,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceExtendedFlagsFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceExtendedFlagsFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceExtendedFlagsFeaturesKHR *>(current);
+                const VkPhysicalDeviceExtendedFlagsFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceExtendedFlagsFeaturesKHR*>(current);
                 if (enabling->extendedFlags && !supported.extendedFlags) {
                     ss << "VkPhysicalDeviceExtendedFlagsFeaturesKHR::extendedFlags is not supported\n";
                 }
@@ -1349,8 +1349,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(current);
+                const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*>(current);
                 if (enabling->extendedSparseAddressSpace && !supported.extendedSparseAddressSpace) {
                     ss << "VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::extendedSparseAddressSpace is not supported\n";
                 }
@@ -1361,8 +1361,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceExternalFormatResolveFeaturesANDROID supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *>(current);
+                const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*>(current);
                 if (enabling->externalFormatResolve && !supported.externalFormatResolve) {
                     ss << "VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::externalFormatResolve is not supported\n";
                 }
@@ -1373,8 +1373,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceExternalMemoryRDMAFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>(current);
+                const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(current);
                 if (enabling->externalMemoryRDMA && !supported.externalMemoryRDMA) {
                     ss << "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::externalMemoryRDMA is not supported\n";
                 }
@@ -1385,8 +1385,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceExternalMemorySciBufFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceExternalMemorySciBufFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceExternalMemorySciBufFeaturesNV *>(current);
+                const VkPhysicalDeviceExternalMemorySciBufFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceExternalMemorySciBufFeaturesNV*>(current);
                 if (enabling->sciBufImport && !supported.sciBufImport) {
                     ss << "VkPhysicalDeviceExternalMemorySciBufFeaturesNV::sciBufImport is not supported\n";
                 }
@@ -1401,8 +1401,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX *>(current);
+                const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*>(current);
                 if (enabling->screenBufferImport && !supported.screenBufferImport) {
                     ss << "VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::screenBufferImport is not supported\n";
                 }
@@ -1414,8 +1414,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceExternalSciSync2FeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceExternalSciSync2FeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceExternalSciSync2FeaturesNV *>(current);
+                const VkPhysicalDeviceExternalSciSync2FeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceExternalSciSync2FeaturesNV*>(current);
                 if (enabling->sciSyncFence && !supported.sciSyncFence) {
                     ss << "VkPhysicalDeviceExternalSciSync2FeaturesNV::sciSyncFence is not supported\n";
                 }
@@ -1436,8 +1436,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceExternalSciSyncFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceExternalSciSyncFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceExternalSciSyncFeaturesNV *>(current);
+                const VkPhysicalDeviceExternalSciSyncFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceExternalSciSyncFeaturesNV*>(current);
                 if (enabling->sciSyncFence && !supported.sciSyncFence) {
                     ss << "VkPhysicalDeviceExternalSciSyncFeaturesNV::sciSyncFence is not supported\n";
                 }
@@ -1457,8 +1457,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceFaultFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceFaultFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT *>(current);
+                const VkPhysicalDeviceFaultFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(current);
                 if (enabling->deviceFault && !supported.deviceFault) {
                     ss << "VkPhysicalDeviceFaultFeaturesEXT::deviceFault is not supported\n";
                 }
@@ -1471,8 +1471,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceFaultFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceFaultFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceFaultFeaturesKHR *>(current);
+                const VkPhysicalDeviceFaultFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceFaultFeaturesKHR*>(current);
                 if (enabling->deviceFault && !supported.deviceFault) {
                     ss << "VkPhysicalDeviceFaultFeaturesKHR::deviceFault is not supported\n";
                 }
@@ -1491,8 +1491,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceFormatPackFeaturesARM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceFormatPackFeaturesARM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceFormatPackFeaturesARM *>(current);
+                const VkPhysicalDeviceFormatPackFeaturesARM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceFormatPackFeaturesARM*>(current);
                 if (enabling->formatPack && !supported.formatPack) {
                     ss << "VkPhysicalDeviceFormatPackFeaturesARM::formatPack is not supported\n";
                 }
@@ -1502,8 +1502,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceFragmentDensityMap2FeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>(current);
+                const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(current);
                 if (enabling->fragmentDensityMapDeferred && !supported.fragmentDensityMapDeferred) {
                     ss << "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::fragmentDensityMapDeferred is not supported\n";
                 }
@@ -1513,8 +1513,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceFragmentDensityMapFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(current);
+                const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(current);
                 if (enabling->fragmentDensityMap && !supported.fragmentDensityMap) {
                     ss << "VkPhysicalDeviceFragmentDensityMapFeaturesEXT::fragmentDensityMap is not supported\n";
                 }
@@ -1530,8 +1530,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *>(current);
+                const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*>(current);
                 if (enabling->fragmentDensityMapLayered && !supported.fragmentDensityMapLayered) {
                     ss << "VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE::fragmentDensityMapLayered is not supported\n";
                 }
@@ -1541,8 +1541,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>(current);
+                const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*>(current);
                 if (enabling->fragmentDensityMapOffset && !supported.fragmentDensityMapOffset) {
                     ss << "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT::fragmentDensityMapOffset is not supported\n";
                 }
@@ -1552,8 +1552,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *>(current);
+                const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(current);
                 if (enabling->fragmentShaderBarycentric && !supported.fragmentShaderBarycentric) {
                     ss << "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::fragmentShaderBarycentric is not supported\n";
                 }
@@ -1563,8 +1563,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(current);
+                const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(current);
                 if (enabling->fragmentShaderSampleInterlock && !supported.fragmentShaderSampleInterlock) {
                     ss << "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::fragmentShaderSampleInterlock is not supported\n";
                 }
@@ -1581,8 +1581,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(current);
+                const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(current);
                 if (enabling->fragmentShadingRateEnums && !supported.fragmentShadingRateEnums) {
                     ss << "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::fragmentShadingRateEnums is not supported\n";
                 }
@@ -1598,8 +1598,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceFragmentShadingRateFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(current);
+                const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(current);
                 if (enabling->pipelineFragmentShadingRate && !supported.pipelineFragmentShadingRate) {
                     ss << "VkPhysicalDeviceFragmentShadingRateFeaturesKHR::pipelineFragmentShadingRate is not supported\n";
                 }
@@ -1615,8 +1615,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceFrameBoundaryFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceFrameBoundaryFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT *>(current);
+                const VkPhysicalDeviceFrameBoundaryFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT*>(current);
                 if (enabling->frameBoundary && !supported.frameBoundary) {
                     ss << "VkPhysicalDeviceFrameBoundaryFeaturesEXT::frameBoundary is not supported\n";
                 }
@@ -1626,8 +1626,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceGlobalPriorityQueryFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceGlobalPriorityQueryFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures *>(current);
+                const VkPhysicalDeviceGlobalPriorityQueryFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures*>(current);
                 if (enabling->globalPriorityQuery && !supported.globalPriorityQuery) {
                     ss << "VkPhysicalDeviceGlobalPriorityQueryFeatures::globalPriorityQuery is not supported\n";
                 }
@@ -1637,7 +1637,7 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceGpaFeaturesAMD supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceGpaFeaturesAMD *enabling = reinterpret_cast<const VkPhysicalDeviceGpaFeaturesAMD *>(current);
+                const VkPhysicalDeviceGpaFeaturesAMD* enabling = reinterpret_cast<const VkPhysicalDeviceGpaFeaturesAMD*>(current);
                 if (enabling->perfCounters && !supported.perfCounters) {
                     ss << "VkPhysicalDeviceGpaFeaturesAMD::perfCounters is not supported\n";
                 }
@@ -1656,8 +1656,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *>(current);
+                const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(current);
                 if (enabling->graphicsPipelineLibrary && !supported.graphicsPipelineLibrary) {
                     ss << "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::graphicsPipelineLibrary is not supported\n";
                 }
@@ -1667,8 +1667,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceHdrVividFeaturesHUAWEI supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceHdrVividFeaturesHUAWEI *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceHdrVividFeaturesHUAWEI *>(current);
+                const VkPhysicalDeviceHdrVividFeaturesHUAWEI* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceHdrVividFeaturesHUAWEI*>(current);
                 if (enabling->hdrVivid && !supported.hdrVivid) {
                     ss << "VkPhysicalDeviceHdrVividFeaturesHUAWEI::hdrVivid is not supported\n";
                 }
@@ -1678,8 +1678,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceHostImageCopyFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceHostImageCopyFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures *>(current);
+                const VkPhysicalDeviceHostImageCopyFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures*>(current);
                 if (enabling->hostImageCopy && !supported.hostImageCopy) {
                     ss << "VkPhysicalDeviceHostImageCopyFeatures::hostImageCopy is not supported\n";
                 }
@@ -1689,8 +1689,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceHostQueryResetFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceHostQueryResetFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures *>(current);
+                const VkPhysicalDeviceHostQueryResetFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(current);
                 if (enabling->hostQueryReset && !supported.hostQueryReset) {
                     ss << "VkPhysicalDeviceHostQueryResetFeatures::hostQueryReset is not supported\n";
                 }
@@ -1700,8 +1700,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceImage2DViewOf3DFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *>(current);
+                const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(current);
                 if (enabling->image2DViewOf3D && !supported.image2DViewOf3D) {
                     ss << "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::image2DViewOf3D is not supported\n";
                 }
@@ -1714,8 +1714,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceImageAlignmentControlFeaturesMESA supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *>(current);
+                const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA*>(current);
                 if (enabling->imageAlignmentControl && !supported.imageAlignmentControl) {
                     ss << "VkPhysicalDeviceImageAlignmentControlFeaturesMESA::imageAlignmentControl is not supported\n";
                 }
@@ -1725,8 +1725,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceImageCompressionControlFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceImageCompressionControlFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT *>(current);
+                const VkPhysicalDeviceImageCompressionControlFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(current);
                 if (enabling->imageCompressionControl && !supported.imageCompressionControl) {
                     ss << "VkPhysicalDeviceImageCompressionControlFeaturesEXT::imageCompressionControl is not supported\n";
                 }
@@ -1736,8 +1736,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *>(current);
+                const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(current);
                 if (enabling->imageCompressionControlSwapchain && !supported.imageCompressionControlSwapchain) {
                     ss << "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::imageCompressionControlSwapchain is not "
                           "supported\n";
@@ -1748,8 +1748,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceImageProcessing2FeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceImageProcessing2FeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM *>(current);
+                const VkPhysicalDeviceImageProcessing2FeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM*>(current);
                 if (enabling->textureBlockMatch2 && !supported.textureBlockMatch2) {
                     ss << "VkPhysicalDeviceImageProcessing2FeaturesQCOM::textureBlockMatch2 is not supported\n";
                 }
@@ -1759,8 +1759,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceImageProcessing3FeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceImageProcessing3FeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceImageProcessing3FeaturesQCOM *>(current);
+                const VkPhysicalDeviceImageProcessing3FeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceImageProcessing3FeaturesQCOM*>(current);
                 if (enabling->imageGatherLinear && !supported.imageGatherLinear) {
                     ss << "VkPhysicalDeviceImageProcessing3FeaturesQCOM::imageGatherLinear is not supported\n";
                 }
@@ -1776,8 +1776,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceImageProcessingFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceImageProcessingFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM *>(current);
+                const VkPhysicalDeviceImageProcessingFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(current);
                 if (enabling->textureSampleWeighted && !supported.textureSampleWeighted) {
                     ss << "VkPhysicalDeviceImageProcessingFeaturesQCOM::textureSampleWeighted is not supported\n";
                 }
@@ -1793,8 +1793,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceImageRobustnessFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceImageRobustnessFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures *>(current);
+                const VkPhysicalDeviceImageRobustnessFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(current);
                 if (enabling->robustImageAccess && !supported.robustImageAccess) {
                     ss << "VkPhysicalDeviceImageRobustnessFeatures::robustImageAccess is not supported\n";
                 }
@@ -1804,8 +1804,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *>(current);
+                const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(current);
                 if (enabling->imageSlicedViewOf3D && !supported.imageSlicedViewOf3D) {
                     ss << "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::imageSlicedViewOf3D is not supported\n";
                 }
@@ -1815,8 +1815,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceImageViewMinLodFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceImageViewMinLodFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT *>(current);
+                const VkPhysicalDeviceImageViewMinLodFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(current);
                 if (enabling->minLod && !supported.minLod) {
                     ss << "VkPhysicalDeviceImageViewMinLodFeaturesEXT::minLod is not supported\n";
                 }
@@ -1826,8 +1826,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceImagelessFramebufferFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceImagelessFramebufferFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures *>(current);
+                const VkPhysicalDeviceImagelessFramebufferFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(current);
                 if (enabling->imagelessFramebuffer && !supported.imagelessFramebuffer) {
                     ss << "VkPhysicalDeviceImagelessFramebufferFeatures::imagelessFramebuffer is not supported\n";
                 }
@@ -1837,8 +1837,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceIndexTypeUint8Features supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceIndexTypeUint8Features *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features *>(current);
+                const VkPhysicalDeviceIndexTypeUint8Features* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features*>(current);
                 if (enabling->indexTypeUint8 && !supported.indexTypeUint8) {
                     ss << "VkPhysicalDeviceIndexTypeUint8Features::indexTypeUint8 is not supported\n";
                 }
@@ -1848,8 +1848,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceInheritedViewportScissorFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>(current);
+                const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(current);
                 if (enabling->inheritedViewportScissor2D && !supported.inheritedViewportScissor2D) {
                     ss << "VkPhysicalDeviceInheritedViewportScissorFeaturesNV::inheritedViewportScissor2D is not supported\n";
                 }
@@ -1859,8 +1859,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceInlineUniformBlockFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceInlineUniformBlockFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures *>(current);
+                const VkPhysicalDeviceInlineUniformBlockFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(current);
                 if (enabling->inlineUniformBlock && !supported.inlineUniformBlock) {
                     ss << "VkPhysicalDeviceInlineUniformBlockFeatures::inlineUniformBlock is not supported\n";
                 }
@@ -1875,8 +1875,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *>(current);
+                const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR*>(current);
                 if (enabling->internallySynchronizedQueues && !supported.internallySynchronizedQueues) {
                     ss << "VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR::internallySynchronizedQueues is not "
                           "supported\n";
@@ -1887,8 +1887,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceInvocationMaskFeaturesHUAWEI supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>(current);
+                const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(current);
                 if (enabling->invocationMask && !supported.invocationMask) {
                     ss << "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::invocationMask is not supported\n";
                 }
@@ -1898,8 +1898,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceLegacyDitheringFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceLegacyDitheringFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT *>(current);
+                const VkPhysicalDeviceLegacyDitheringFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(current);
                 if (enabling->legacyDithering && !supported.legacyDithering) {
                     ss << "VkPhysicalDeviceLegacyDitheringFeaturesEXT::legacyDithering is not supported\n";
                 }
@@ -1909,8 +1909,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *>(current);
+                const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*>(current);
                 if (enabling->legacyVertexAttributes && !supported.legacyVertexAttributes) {
                     ss << "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT::legacyVertexAttributes is not supported\n";
                 }
@@ -1920,8 +1920,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceLineRasterizationFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceLineRasterizationFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures *>(current);
+                const VkPhysicalDeviceLineRasterizationFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures*>(current);
                 if (enabling->rectangularLines && !supported.rectangularLines) {
                     ss << "VkPhysicalDeviceLineRasterizationFeatures::rectangularLines is not supported\n";
                 }
@@ -1946,8 +1946,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceLinearColorAttachmentFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(current);
+                const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(current);
                 if (enabling->linearColorAttachment && !supported.linearColorAttachment) {
                     ss << "VkPhysicalDeviceLinearColorAttachmentFeaturesNV::linearColorAttachment is not supported\n";
                 }
@@ -1957,8 +1957,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMaintenance10FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMaintenance10FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance10FeaturesKHR *>(current);
+                const VkPhysicalDeviceMaintenance10FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance10FeaturesKHR*>(current);
                 if (enabling->maintenance10 && !supported.maintenance10) {
                     ss << "VkPhysicalDeviceMaintenance10FeaturesKHR::maintenance10 is not supported\n";
                 }
@@ -1968,8 +1968,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMaintenance11FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMaintenance11FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance11FeaturesKHR *>(current);
+                const VkPhysicalDeviceMaintenance11FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance11FeaturesKHR*>(current);
                 if (enabling->maintenance11 && !supported.maintenance11) {
                     ss << "VkPhysicalDeviceMaintenance11FeaturesKHR::maintenance11 is not supported\n";
                 }
@@ -1979,8 +1979,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMaintenance4Features supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMaintenance4Features *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance4Features *>(current);
+                const VkPhysicalDeviceMaintenance4Features* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(current);
                 if (enabling->maintenance4 && !supported.maintenance4) {
                     ss << "VkPhysicalDeviceMaintenance4Features::maintenance4 is not supported\n";
                 }
@@ -1990,8 +1990,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMaintenance5Features supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMaintenance5Features *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance5Features *>(current);
+                const VkPhysicalDeviceMaintenance5Features* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance5Features*>(current);
                 if (enabling->maintenance5 && !supported.maintenance5) {
                     ss << "VkPhysicalDeviceMaintenance5Features::maintenance5 is not supported\n";
                 }
@@ -2001,8 +2001,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMaintenance6Features supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMaintenance6Features *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance6Features *>(current);
+                const VkPhysicalDeviceMaintenance6Features* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance6Features*>(current);
                 if (enabling->maintenance6 && !supported.maintenance6) {
                     ss << "VkPhysicalDeviceMaintenance6Features::maintenance6 is not supported\n";
                 }
@@ -2012,8 +2012,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMaintenance7FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMaintenance7FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance7FeaturesKHR *>(current);
+                const VkPhysicalDeviceMaintenance7FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance7FeaturesKHR*>(current);
                 if (enabling->maintenance7 && !supported.maintenance7) {
                     ss << "VkPhysicalDeviceMaintenance7FeaturesKHR::maintenance7 is not supported\n";
                 }
@@ -2023,8 +2023,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMaintenance8FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMaintenance8FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance8FeaturesKHR *>(current);
+                const VkPhysicalDeviceMaintenance8FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance8FeaturesKHR*>(current);
                 if (enabling->maintenance8 && !supported.maintenance8) {
                     ss << "VkPhysicalDeviceMaintenance8FeaturesKHR::maintenance8 is not supported\n";
                 }
@@ -2034,8 +2034,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMaintenance9FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMaintenance9FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMaintenance9FeaturesKHR *>(current);
+                const VkPhysicalDeviceMaintenance9FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMaintenance9FeaturesKHR*>(current);
                 if (enabling->maintenance9 && !supported.maintenance9) {
                     ss << "VkPhysicalDeviceMaintenance9FeaturesKHR::maintenance9 is not supported\n";
                 }
@@ -2045,8 +2045,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMapMemoryPlacedFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *>(current);
+                const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(current);
                 if (enabling->memoryMapPlaced && !supported.memoryMapPlaced) {
                     ss << "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::memoryMapPlaced is not supported\n";
                 }
@@ -2062,8 +2062,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMemoryDecompressionFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMemoryDecompressionFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesEXT *>(current);
+                const VkPhysicalDeviceMemoryDecompressionFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesEXT*>(current);
                 if (enabling->memoryDecompression && !supported.memoryDecompression) {
                     ss << "VkPhysicalDeviceMemoryDecompressionFeaturesEXT::memoryDecompression is not supported\n";
                 }
@@ -2073,8 +2073,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMemoryPriorityFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMemoryPriorityFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(current);
+                const VkPhysicalDeviceMemoryPriorityFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(current);
                 if (enabling->memoryPriority && !supported.memoryPriority) {
                     ss << "VkPhysicalDeviceMemoryPriorityFeaturesEXT::memoryPriority is not supported\n";
                 }
@@ -2084,8 +2084,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMeshShaderFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMeshShaderFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT *>(current);
+                const VkPhysicalDeviceMeshShaderFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(current);
                 if (enabling->taskShader && !supported.taskShader) {
                     ss << "VkPhysicalDeviceMeshShaderFeaturesEXT::taskShader is not supported\n";
                 }
@@ -2107,8 +2107,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMeshShaderFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMeshShaderFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV *>(current);
+                const VkPhysicalDeviceMeshShaderFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(current);
                 if (enabling->taskShader && !supported.taskShader) {
                     ss << "VkPhysicalDeviceMeshShaderFeaturesNV::taskShader is not supported\n";
                 }
@@ -2121,8 +2121,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMultiDrawFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMultiDrawFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT *>(current);
+                const VkPhysicalDeviceMultiDrawFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(current);
                 if (enabling->multiDraw && !supported.multiDraw) {
                     ss << "VkPhysicalDeviceMultiDrawFeaturesEXT::multiDraw is not supported\n";
                 }
@@ -2132,8 +2132,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *>(current);
+                const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(current);
                 if (enabling->multisampledRenderToSingleSampled && !supported.multisampledRenderToSingleSampled) {
                     ss << "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::multisampledRenderToSingleSampled is not "
                           "supported\n";
@@ -2144,8 +2144,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT *>(current);
+                const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT*>(current);
                 if (enabling->multisampledRenderToSwapchain && !supported.multisampledRenderToSwapchain) {
                     ss << "VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT::multisampledRenderToSwapchain is not "
                           "supported\n";
@@ -2156,8 +2156,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMultiviewFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMultiviewFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures *>(current);
+                const VkPhysicalDeviceMultiviewFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(current);
                 if (enabling->multiview && !supported.multiview) {
                     ss << "VkPhysicalDeviceMultiviewFeatures::multiview is not supported\n";
                 }
@@ -2173,8 +2173,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *>(current);
+                const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(current);
                 if (enabling->multiviewPerViewRenderAreas && !supported.multiviewPerViewRenderAreas) {
                     ss << "VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::multiviewPerViewRenderAreas is not supported\n";
                 }
@@ -2184,8 +2184,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *>(current);
+                const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(current);
                 if (enabling->multiviewPerViewViewports && !supported.multiviewPerViewViewports) {
                     ss << "VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::multiviewPerViewViewports is not supported\n";
                 }
@@ -2195,8 +2195,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *>(current);
+                const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(current);
                 if (enabling->mutableDescriptorType && !supported.mutableDescriptorType) {
                     ss << "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::mutableDescriptorType is not supported\n";
                 }
@@ -2206,8 +2206,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceNestedCommandBufferFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *>(current);
+                const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(current);
                 if (enabling->nestedCommandBuffer && !supported.nestedCommandBuffer) {
                     ss << "VkPhysicalDeviceNestedCommandBufferFeaturesEXT::nestedCommandBuffer is not supported\n";
                 }
@@ -2223,8 +2223,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *>(current);
+                const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(current);
                 if (enabling->nonSeamlessCubeMap && !supported.nonSeamlessCubeMap) {
                     ss << "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::nonSeamlessCubeMap is not supported\n";
                 }
@@ -2234,8 +2234,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceOpacityMicromapFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceOpacityMicromapFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT *>(current);
+                const VkPhysicalDeviceOpacityMicromapFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(current);
                 if (enabling->micromap && !supported.micromap) {
                     ss << "VkPhysicalDeviceOpacityMicromapFeaturesEXT::micromap is not supported\n";
                 }
@@ -2251,8 +2251,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceOpacityMicromapFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceOpacityMicromapFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesKHR *>(current);
+                const VkPhysicalDeviceOpacityMicromapFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesKHR*>(current);
                 if (enabling->micromap && !supported.micromap) {
                     ss << "VkPhysicalDeviceOpacityMicromapFeaturesKHR::micromap is not supported\n";
                 }
@@ -2262,8 +2262,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceOpticalFlowFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceOpticalFlowFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV *>(current);
+                const VkPhysicalDeviceOpticalFlowFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(current);
                 if (enabling->opticalFlow && !supported.opticalFlow) {
                     ss << "VkPhysicalDeviceOpticalFlowFeaturesNV::opticalFlow is not supported\n";
                 }
@@ -2273,8 +2273,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>(current);
+                const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(current);
                 if (enabling->pageableDeviceLocalMemory && !supported.pageableDeviceLocalMemory) {
                     ss << "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::pageableDeviceLocalMemory is not supported\n";
                 }
@@ -2284,8 +2284,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *>(current);
+                const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*>(current);
                 if (enabling->partitionedAccelerationStructure && !supported.partitionedAccelerationStructure) {
                     ss << "VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV::partitionedAccelerationStructure is not "
                           "supported\n";
@@ -2296,8 +2296,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePerStageDescriptorSetFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *>(current);
+                const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV*>(current);
                 if (enabling->perStageDescriptorSet && !supported.perStageDescriptorSet) {
                     ss << "VkPhysicalDevicePerStageDescriptorSetFeaturesNV::perStageDescriptorSet is not supported\n";
                 }
@@ -2310,8 +2310,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePerformanceCountersByRegionFeaturesARM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM *>(current);
+                const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM*>(current);
                 if (enabling->performanceCountersByRegion && !supported.performanceCountersByRegion) {
                     ss << "VkPhysicalDevicePerformanceCountersByRegionFeaturesARM::performanceCountersByRegion is not supported\n";
                 }
@@ -2321,8 +2321,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePerformanceQueryFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePerformanceQueryFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR *>(current);
+                const VkPhysicalDevicePerformanceQueryFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(current);
                 if (enabling->performanceCounterQueryPools && !supported.performanceCounterQueryPools) {
                     ss << "VkPhysicalDevicePerformanceQueryFeaturesKHR::performanceCounterQueryPools is not supported\n";
                 }
@@ -2335,8 +2335,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePipelineBinaryFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePipelineBinaryFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR *>(current);
+                const VkPhysicalDevicePipelineBinaryFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR*>(current);
                 if (enabling->pipelineBinaries && !supported.pipelineBinaries) {
                     ss << "VkPhysicalDevicePipelineBinaryFeaturesKHR::pipelineBinaries is not supported\n";
                 }
@@ -2346,8 +2346,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *>(current);
+                const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC*>(current);
                 if (enabling->pipelineCacheIncrementalMode && !supported.pipelineCacheIncrementalMode) {
                     ss << "VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC::pipelineCacheIncrementalMode is not "
                           "supported\n";
@@ -2358,8 +2358,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePipelineCreationCacheControlFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePipelineCreationCacheControlFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures *>(current);
+                const VkPhysicalDevicePipelineCreationCacheControlFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(current);
                 if (enabling->pipelineCreationCacheControl && !supported.pipelineCreationCacheControl) {
                     ss << "VkPhysicalDevicePipelineCreationCacheControlFeatures::pipelineCreationCacheControl is not supported\n";
                 }
@@ -2369,8 +2369,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(current);
+                const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(current);
                 if (enabling->pipelineExecutableInfo && !supported.pipelineExecutableInfo) {
                     ss << "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::pipelineExecutableInfo is not supported\n";
                 }
@@ -2380,8 +2380,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *>(current);
+                const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(current);
                 if (enabling->pipelineLibraryGroupHandles && !supported.pipelineLibraryGroupHandles) {
                     ss << "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::pipelineLibraryGroupHandles is not supported\n";
                 }
@@ -2391,8 +2391,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePipelineOpacityMicromapFeaturesARM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *>(current);
+                const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM*>(current);
                 if (enabling->pipelineOpacityMicromap && !supported.pipelineOpacityMicromap) {
                     ss << "VkPhysicalDevicePipelineOpacityMicromapFeaturesARM::pipelineOpacityMicromap is not supported\n";
                 }
@@ -2402,8 +2402,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePipelinePropertiesFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePipelinePropertiesFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT *>(current);
+                const VkPhysicalDevicePipelinePropertiesFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(current);
                 if (enabling->pipelinePropertiesIdentifier && !supported.pipelinePropertiesIdentifier) {
                     ss << "VkPhysicalDevicePipelinePropertiesFeaturesEXT::pipelinePropertiesIdentifier is not supported\n";
                 }
@@ -2413,8 +2413,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePipelineProtectedAccessFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePipelineProtectedAccessFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures *>(current);
+                const VkPhysicalDevicePipelineProtectedAccessFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures*>(current);
                 if (enabling->pipelineProtectedAccess && !supported.pipelineProtectedAccess) {
                     ss << "VkPhysicalDevicePipelineProtectedAccessFeatures::pipelineProtectedAccess is not supported\n";
                 }
@@ -2424,8 +2424,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePipelineRobustnessFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePipelineRobustnessFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures *>(current);
+                const VkPhysicalDevicePipelineRobustnessFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures*>(current);
                 if (enabling->pipelineRobustness && !supported.pipelineRobustness) {
                     ss << "VkPhysicalDevicePipelineRobustnessFeatures::pipelineRobustness is not supported\n";
                 }
@@ -2436,8 +2436,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePortabilitySubsetFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePortabilitySubsetFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(current);
+                const VkPhysicalDevicePortabilitySubsetFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(current);
                 if (enabling->constantAlphaColorBlendFactors && !supported.constantAlphaColorBlendFactors) {
                     ss << "VkPhysicalDevicePortabilitySubsetFeaturesKHR::constantAlphaColorBlendFactors is not supported\n";
                 }
@@ -2490,8 +2490,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePresentBarrierFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePresentBarrierFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV *>(current);
+                const VkPhysicalDevicePresentBarrierFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(current);
                 if (enabling->presentBarrier && !supported.presentBarrier) {
                     ss << "VkPhysicalDevicePresentBarrierFeaturesNV::presentBarrier is not supported\n";
                 }
@@ -2501,8 +2501,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePresentId2FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePresentId2FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePresentId2FeaturesKHR *>(current);
+                const VkPhysicalDevicePresentId2FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePresentId2FeaturesKHR*>(current);
                 if (enabling->presentId2 && !supported.presentId2) {
                     ss << "VkPhysicalDevicePresentId2FeaturesKHR::presentId2 is not supported\n";
                 }
@@ -2512,8 +2512,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePresentIdFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePresentIdFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR *>(current);
+                const VkPhysicalDevicePresentIdFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(current);
                 if (enabling->presentId && !supported.presentId) {
                     ss << "VkPhysicalDevicePresentIdFeaturesKHR::presentId is not supported\n";
                 }
@@ -2523,8 +2523,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePresentMeteringFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePresentMeteringFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV *>(current);
+                const VkPhysicalDevicePresentMeteringFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV*>(current);
                 if (enabling->presentMetering && !supported.presentMetering) {
                     ss << "VkPhysicalDevicePresentMeteringFeaturesNV::presentMetering is not supported\n";
                 }
@@ -2534,8 +2534,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *>(current);
+                const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*>(current);
                 if (enabling->presentModeFifoLatestReady && !supported.presentModeFifoLatestReady) {
                     ss << "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR::presentModeFifoLatestReady is not supported\n";
                 }
@@ -2545,8 +2545,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePresentTimingFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePresentTimingFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePresentTimingFeaturesEXT *>(current);
+                const VkPhysicalDevicePresentTimingFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePresentTimingFeaturesEXT*>(current);
                 if (enabling->presentTiming && !supported.presentTiming) {
                     ss << "VkPhysicalDevicePresentTimingFeaturesEXT::presentTiming is not supported\n";
                 }
@@ -2562,8 +2562,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePresentWait2FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePresentWait2FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePresentWait2FeaturesKHR *>(current);
+                const VkPhysicalDevicePresentWait2FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePresentWait2FeaturesKHR*>(current);
                 if (enabling->presentWait2 && !supported.presentWait2) {
                     ss << "VkPhysicalDevicePresentWait2FeaturesKHR::presentWait2 is not supported\n";
                 }
@@ -2573,8 +2573,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePresentWaitFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePresentWaitFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR *>(current);
+                const VkPhysicalDevicePresentWaitFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(current);
                 if (enabling->presentWait && !supported.presentWait) {
                     ss << "VkPhysicalDevicePresentWaitFeaturesKHR::presentWait is not supported\n";
                 }
@@ -2584,8 +2584,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT *>(current);
+                const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT*>(current);
                 if (enabling->primitiveRestartIndex && !supported.primitiveRestartIndex) {
                     ss << "VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT::primitiveRestartIndex is not supported\n";
                 }
@@ -2595,8 +2595,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(current);
+                const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(current);
                 if (enabling->primitiveTopologyListRestart && !supported.primitiveTopologyListRestart) {
                     ss << "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::primitiveTopologyListRestart is not "
                           "supported\n";
@@ -2611,8 +2611,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(current);
+                const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(current);
                 if (enabling->primitivesGeneratedQuery && !supported.primitivesGeneratedQuery) {
                     ss << "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::primitivesGeneratedQuery is not supported\n";
                 }
@@ -2631,8 +2631,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePrivateDataFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePrivateDataFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures *>(current);
+                const VkPhysicalDevicePrivateDataFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(current);
                 if (enabling->privateData && !supported.privateData) {
                     ss << "VkPhysicalDevicePrivateDataFeatures::privateData is not supported\n";
                 }
@@ -2642,8 +2642,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceProtectedMemoryFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceProtectedMemoryFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures *>(current);
+                const VkPhysicalDeviceProtectedMemoryFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(current);
                 if (enabling->protectedMemory && !supported.protectedMemory) {
                     ss << "VkPhysicalDeviceProtectedMemoryFeatures::protectedMemory is not supported\n";
                 }
@@ -2653,8 +2653,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceProvokingVertexFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceProvokingVertexFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT *>(current);
+                const VkPhysicalDeviceProvokingVertexFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(current);
                 if (enabling->provokingVertexLast && !supported.provokingVertexLast) {
                     ss << "VkPhysicalDeviceProvokingVertexFeaturesEXT::provokingVertexLast is not supported\n";
                 }
@@ -2668,8 +2668,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDevicePushConstantBankFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDevicePushConstantBankFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDevicePushConstantBankFeaturesNV *>(current);
+                const VkPhysicalDevicePushConstantBankFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDevicePushConstantBankFeaturesNV*>(current);
                 if (enabling->pushConstantBank && !supported.pushConstantBank) {
                     ss << "VkPhysicalDevicePushConstantBankFeaturesNV::pushConstantBank is not supported\n";
                 }
@@ -2679,8 +2679,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceQueuePerfHintFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceQueuePerfHintFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceQueuePerfHintFeaturesQCOM *>(current);
+                const VkPhysicalDeviceQueuePerfHintFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceQueuePerfHintFeaturesQCOM*>(current);
                 if (enabling->queuePerfHint && !supported.queuePerfHint) {
                     ss << "VkPhysicalDeviceQueuePerfHintFeaturesQCOM::queuePerfHint is not supported\n";
                 }
@@ -2690,8 +2690,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>(current);
+                const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(current);
                 if (enabling->formatRgba10x6WithoutYCbCrSampler && !supported.formatRgba10x6WithoutYCbCrSampler) {
                     ss << "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::formatRgba10x6WithoutYCbCrSampler is not supported\n";
                 }
@@ -2701,8 +2701,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *>(current);
+                const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(current);
                 if (enabling->rasterizationOrderColorAttachmentAccess && !supported.rasterizationOrderColorAttachmentAccess) {
                     ss << "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::rasterizationOrderColorAttachmentAccess "
                           "is not supported\n";
@@ -2721,8 +2721,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRawAccessChainsFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRawAccessChainsFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV *>(current);
+                const VkPhysicalDeviceRawAccessChainsFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV*>(current);
                 if (enabling->shaderRawAccessChains && !supported.shaderRawAccessChains) {
                     ss << "VkPhysicalDeviceRawAccessChainsFeaturesNV::shaderRawAccessChains is not supported\n";
                 }
@@ -2732,8 +2732,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRayQueryFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRayQueryFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR *>(current);
+                const VkPhysicalDeviceRayQueryFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(current);
                 if (enabling->rayQuery && !supported.rayQuery) {
                     ss << "VkPhysicalDeviceRayQueryFeaturesKHR::rayQuery is not supported\n";
                 }
@@ -2743,8 +2743,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT *>(current);
+                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT*>(current);
                 if (enabling->rayTracingInvocationReorder && !supported.rayTracingInvocationReorder) {
                     ss << "VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT::rayTracingInvocationReorder is not supported\n";
                 }
@@ -2754,8 +2754,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *>(current);
+                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(current);
                 if (enabling->rayTracingInvocationReorder && !supported.rayTracingInvocationReorder) {
                     ss << "VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::rayTracingInvocationReorder is not supported\n";
                 }
@@ -2765,8 +2765,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *>(current);
+                const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*>(current);
                 if (enabling->spheres && !supported.spheres) {
                     ss << "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV::spheres is not supported\n";
                 }
@@ -2779,8 +2779,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *>(current);
+                const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(current);
                 if (enabling->rayTracingMaintenance1 && !supported.rayTracingMaintenance1) {
                     ss << "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::rayTracingMaintenance1 is not supported\n";
                 }
@@ -2794,8 +2794,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRayTracingMotionBlurFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>(current);
+                const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(current);
                 if (enabling->rayTracingMotionBlur && !supported.rayTracingMotionBlur) {
                     ss << "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::rayTracingMotionBlur is not supported\n";
                 }
@@ -2810,8 +2810,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRayTracingPipelineFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(current);
+                const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(current);
                 if (enabling->rayTracingPipeline && !supported.rayTracingPipeline) {
                     ss << "VkPhysicalDeviceRayTracingPipelineFeaturesKHR::rayTracingPipeline is not supported\n";
                 }
@@ -2837,8 +2837,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(current);
+                const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(current);
                 if (enabling->rayTracingPositionFetch && !supported.rayTracingPositionFetch) {
                     ss << "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::rayTracingPositionFetch is not supported\n";
                 }
@@ -2848,8 +2848,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRayTracingValidationFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRayTracingValidationFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>(current);
+                const VkPhysicalDeviceRayTracingValidationFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV*>(current);
                 if (enabling->rayTracingValidation && !supported.rayTracingValidation) {
                     ss << "VkPhysicalDeviceRayTracingValidationFeaturesNV::rayTracingValidation is not supported\n";
                 }
@@ -2859,8 +2859,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *>(current);
+                const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(current);
                 if (enabling->relaxedLineRasterization && !supported.relaxedLineRasterization) {
                     ss << "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::relaxedLineRasterization is not supported\n";
                 }
@@ -2870,8 +2870,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRenderPassStripedFeaturesARM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRenderPassStripedFeaturesARM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM *>(current);
+                const VkPhysicalDeviceRenderPassStripedFeaturesARM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM*>(current);
                 if (enabling->renderPassStriped && !supported.renderPassStriped) {
                     ss << "VkPhysicalDeviceRenderPassStripedFeaturesARM::renderPassStriped is not supported\n";
                 }
@@ -2881,8 +2881,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(current);
+                const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(current);
                 if (enabling->representativeFragmentTest && !supported.representativeFragmentTest) {
                     ss << "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::representativeFragmentTest is not supported\n";
                 }
@@ -2892,8 +2892,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceRobustness2FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceRobustness2FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR *>(current);
+                const VkPhysicalDeviceRobustness2FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR*>(current);
                 if (enabling->robustBufferAccess2 && !supported.robustBufferAccess2) {
                     ss << "VkPhysicalDeviceRobustness2FeaturesKHR::robustBufferAccess2 is not supported\n";
                 }
@@ -2909,8 +2909,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceSamplerYcbcrConversionFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceSamplerYcbcrConversionFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(current);
+                const VkPhysicalDeviceSamplerYcbcrConversionFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(current);
                 if (enabling->samplerYcbcrConversion && !supported.samplerYcbcrConversion) {
                     ss << "VkPhysicalDeviceSamplerYcbcrConversionFeatures::samplerYcbcrConversion is not supported\n";
                 }
@@ -2920,8 +2920,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceScalarBlockLayoutFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceScalarBlockLayoutFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures *>(current);
+                const VkPhysicalDeviceScalarBlockLayoutFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(current);
                 if (enabling->scalarBlockLayout && !supported.scalarBlockLayout) {
                     ss << "VkPhysicalDeviceScalarBlockLayoutFeatures::scalarBlockLayout is not supported\n";
                 }
@@ -2931,8 +2931,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceSchedulingControlsFeaturesARM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceSchedulingControlsFeaturesARM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM *>(current);
+                const VkPhysicalDeviceSchedulingControlsFeaturesARM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM*>(current);
                 if (enabling->schedulingControls && !supported.schedulingControls) {
                     ss << "VkPhysicalDeviceSchedulingControlsFeaturesARM::schedulingControls is not supported\n";
                 }
@@ -2942,8 +2942,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(current);
+                const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(current);
                 if (enabling->separateDepthStencilLayouts && !supported.separateDepthStencilLayouts) {
                     ss << "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::separateDepthStencilLayouts is not supported\n";
                 }
@@ -2953,8 +2953,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShader64BitIndexingFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShader64BitIndexingFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShader64BitIndexingFeaturesEXT *>(current);
+                const VkPhysicalDeviceShader64BitIndexingFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShader64BitIndexingFeaturesEXT*>(current);
                 if (enabling->shader64BitIndexing && !supported.shader64BitIndexing) {
                     ss << "VkPhysicalDeviceShader64BitIndexingFeaturesEXT::shader64BitIndexing is not supported\n";
                 }
@@ -2964,8 +2964,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderAbortFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderAbortFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderAbortFeaturesKHR *>(current);
+                const VkPhysicalDeviceShaderAbortFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderAbortFeaturesKHR*>(current);
                 if (enabling->shaderAbort && !supported.shaderAbort) {
                     ss << "VkPhysicalDeviceShaderAbortFeaturesKHR::shaderAbort is not supported\n";
                 }
@@ -2975,8 +2975,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(current);
+                const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*>(current);
                 if (enabling->shaderFloat16VectorAtomics && !supported.shaderFloat16VectorAtomics) {
                     ss << "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::shaderFloat16VectorAtomics is not supported\n";
                 }
@@ -2986,8 +2986,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(current);
+                const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(current);
                 if (enabling->shaderBufferFloat16Atomics && !supported.shaderBufferFloat16Atomics) {
                     ss << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::shaderBufferFloat16Atomics is not supported\n";
                 }
@@ -3030,8 +3030,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderAtomicFloatFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(current);
+                const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(current);
                 if (enabling->shaderBufferFloat32Atomics && !supported.shaderBufferFloat32Atomics) {
                     ss << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::shaderBufferFloat32Atomics is not supported\n";
                 }
@@ -3074,8 +3074,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderAtomicInt64Features supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderAtomicInt64Features *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features *>(current);
+                const VkPhysicalDeviceShaderAtomicInt64Features* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(current);
                 if (enabling->shaderBufferInt64Atomics && !supported.shaderBufferInt64Atomics) {
                     ss << "VkPhysicalDeviceShaderAtomicInt64Features::shaderBufferInt64Atomics is not supported\n";
                 }
@@ -3088,8 +3088,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderBfloat16FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderBfloat16FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR *>(current);
+                const VkPhysicalDeviceShaderBfloat16FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR*>(current);
                 if (enabling->shaderBFloat16Type && !supported.shaderBFloat16Type) {
                     ss << "VkPhysicalDeviceShaderBfloat16FeaturesKHR::shaderBFloat16Type is not supported\n";
                 }
@@ -3105,8 +3105,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderClockFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderClockFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR *>(current);
+                const VkPhysicalDeviceShaderClockFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(current);
                 if (enabling->shaderSubgroupClock && !supported.shaderSubgroupClock) {
                     ss << "VkPhysicalDeviceShaderClockFeaturesKHR::shaderSubgroupClock is not supported\n";
                 }
@@ -3119,8 +3119,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderConstantDataFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderConstantDataFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderConstantDataFeaturesKHR *>(current);
+                const VkPhysicalDeviceShaderConstantDataFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderConstantDataFeaturesKHR*>(current);
                 if (enabling->shaderConstantData && !supported.shaderConstantData) {
                     ss << "VkPhysicalDeviceShaderConstantDataFeaturesKHR::shaderConstantData is not supported\n";
                 }
@@ -3130,8 +3130,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *>(current);
+                const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(current);
                 if (enabling->shaderCoreBuiltins && !supported.shaderCoreBuiltins) {
                     ss << "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::shaderCoreBuiltins is not supported\n";
                 }
@@ -3141,8 +3141,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *>(current);
+                const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(current);
                 if (enabling->shaderDemoteToHelperInvocation && !supported.shaderDemoteToHelperInvocation) {
                     ss << "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::shaderDemoteToHelperInvocation is not "
                           "supported\n";
@@ -3153,8 +3153,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderDrawParametersFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderDrawParametersFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures *>(current);
+                const VkPhysicalDeviceShaderDrawParametersFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(current);
                 if (enabling->shaderDrawParameters && !supported.shaderDrawParameters) {
                     ss << "VkPhysicalDeviceShaderDrawParametersFeatures::shaderDrawParameters is not supported\n";
                 }
@@ -3164,8 +3164,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *>(current);
+                const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(current);
                 if (enabling->shaderEarlyAndLateFragmentTests && !supported.shaderEarlyAndLateFragmentTests) {
                     ss << "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::shaderEarlyAndLateFragmentTests is not "
                           "supported\n";
@@ -3177,8 +3177,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderEnqueueFeaturesAMDX supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderEnqueueFeaturesAMDX *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX *>(current);
+                const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX*>(current);
                 if (enabling->shaderEnqueue && !supported.shaderEnqueue) {
                     ss << "VkPhysicalDeviceShaderEnqueueFeaturesAMDX::shaderEnqueue is not supported\n";
                 }
@@ -3192,8 +3192,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderExpectAssumeFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderExpectAssumeFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures *>(current);
+                const VkPhysicalDeviceShaderExpectAssumeFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures*>(current);
                 if (enabling->shaderExpectAssume && !supported.shaderExpectAssume) {
                     ss << "VkPhysicalDeviceShaderExpectAssumeFeatures::shaderExpectAssume is not supported\n";
                 }
@@ -3203,8 +3203,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderFloat16Int8Features supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderFloat16Int8Features *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features *>(current);
+                const VkPhysicalDeviceShaderFloat16Int8Features* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(current);
                 if (enabling->shaderFloat16 && !supported.shaderFloat16) {
                     ss << "VkPhysicalDeviceShaderFloat16Int8Features::shaderFloat16 is not supported\n";
                 }
@@ -3217,8 +3217,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderFloat8FeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderFloat8FeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderFloat8FeaturesEXT *>(current);
+                const VkPhysicalDeviceShaderFloat8FeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderFloat8FeaturesEXT*>(current);
                 if (enabling->shaderFloat8 && !supported.shaderFloat8) {
                     ss << "VkPhysicalDeviceShaderFloat8FeaturesEXT::shaderFloat8 is not supported\n";
                 }
@@ -3231,8 +3231,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderFloatControls2Features supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderFloatControls2Features *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features *>(current);
+                const VkPhysicalDeviceShaderFloatControls2Features* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features*>(current);
                 if (enabling->shaderFloatControls2 && !supported.shaderFloatControls2) {
                     ss << "VkPhysicalDeviceShaderFloatControls2Features::shaderFloatControls2 is not supported\n";
                 }
@@ -3242,8 +3242,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderFmaFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderFmaFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR *>(current);
+                const VkPhysicalDeviceShaderFmaFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR*>(current);
                 if (enabling->shaderFmaFloat16 && !supported.shaderFmaFloat16) {
                     ss << "VkPhysicalDeviceShaderFmaFeaturesKHR::shaderFmaFloat16 is not supported\n";
                 }
@@ -3259,8 +3259,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(current);
+                const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(current);
                 if (enabling->shaderImageInt64Atomics && !supported.shaderImageInt64Atomics) {
                     ss << "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::shaderImageInt64Atomics is not supported\n";
                 }
@@ -3273,8 +3273,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderImageFootprintFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderImageFootprintFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(current);
+                const VkPhysicalDeviceShaderImageFootprintFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(current);
                 if (enabling->imageFootprint && !supported.imageFootprint) {
                     ss << "VkPhysicalDeviceShaderImageFootprintFeaturesNV::imageFootprint is not supported\n";
                 }
@@ -3284,8 +3284,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderInstrumentationFeaturesARM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderInstrumentationFeaturesARM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationFeaturesARM *>(current);
+                const VkPhysicalDeviceShaderInstrumentationFeaturesARM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationFeaturesARM*>(current);
                 if (enabling->shaderInstrumentation && !supported.shaderInstrumentation) {
                     ss << "VkPhysicalDeviceShaderInstrumentationFeaturesARM::shaderInstrumentation is not supported\n";
                 }
@@ -3295,8 +3295,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderIntegerDotProductFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderIntegerDotProductFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures *>(current);
+                const VkPhysicalDeviceShaderIntegerDotProductFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(current);
                 if (enabling->shaderIntegerDotProduct && !supported.shaderIntegerDotProduct) {
                     ss << "VkPhysicalDeviceShaderIntegerDotProductFeatures::shaderIntegerDotProduct is not supported\n";
                 }
@@ -3306,8 +3306,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(current);
+                const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(current);
                 if (enabling->shaderIntegerFunctions2 && !supported.shaderIntegerFunctions2) {
                     ss << "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::shaderIntegerFunctions2 is not supported\n";
                 }
@@ -3317,8 +3317,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderLongVectorFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderLongVectorFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderLongVectorFeaturesEXT *>(current);
+                const VkPhysicalDeviceShaderLongVectorFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderLongVectorFeaturesEXT*>(current);
                 if (enabling->longVector && !supported.longVector) {
                     ss << "VkPhysicalDeviceShaderLongVectorFeaturesEXT::longVector is not supported\n";
                 }
@@ -3328,8 +3328,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(current);
+                const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*>(current);
                 if (enabling->shaderMaximalReconvergence && !supported.shaderMaximalReconvergence) {
                     ss << "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::shaderMaximalReconvergence is not supported\n";
                 }
@@ -3339,8 +3339,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE *>(current);
+                const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE*>(current);
                 if (enabling->shaderMixedFloatDotProductFloat16AccFloat32 &&
                     !supported.shaderMixedFloatDotProductFloat16AccFloat32) {
                     ss << "VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE::shaderMixedFloatDotProductFloat16AccFloat32 is "
@@ -3365,8 +3365,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(current);
+                const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(current);
                 if (enabling->shaderModuleIdentifier && !supported.shaderModuleIdentifier) {
                     ss << "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::shaderModuleIdentifier is not supported\n";
                 }
@@ -3376,8 +3376,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *>(current);
+                const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM*>(current);
                 if (enabling->shaderMultipleWaitQueues && !supported.shaderMultipleWaitQueues) {
                     ss << "VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM::shaderMultipleWaitQueues is not supported\n";
                 }
@@ -3387,8 +3387,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT *>(current);
+                const VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT*>(current);
                 if (enabling->shaderFloat4 && !supported.shaderFloat4) {
                     ss << "VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT::shaderFloat4 is not supported\n";
                 }
@@ -3407,8 +3407,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderObjectFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderObjectFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT *>(current);
+                const VkPhysicalDeviceShaderObjectFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(current);
                 if (enabling->shaderObject && !supported.shaderObject) {
                     ss << "VkPhysicalDeviceShaderObjectFeaturesEXT::shaderObject is not supported\n";
                 }
@@ -3418,8 +3418,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderQuadControlFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderQuadControlFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR *>(current);
+                const VkPhysicalDeviceShaderQuadControlFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR*>(current);
                 if (enabling->shaderQuadControl && !supported.shaderQuadControl) {
                     ss << "VkPhysicalDeviceShaderQuadControlFeaturesKHR::shaderQuadControl is not supported\n";
                 }
@@ -3429,8 +3429,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(current);
+                const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*>(current);
                 if (enabling->shaderRelaxedExtendedInstruction && !supported.shaderRelaxedExtendedInstruction) {
                     ss << "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::shaderRelaxedExtendedInstruction is not "
                           "supported\n";
@@ -3441,8 +3441,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *>(current);
+                const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*>(current);
                 if (enabling->shaderReplicatedComposites && !supported.shaderReplicatedComposites) {
                     ss << "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT::shaderReplicatedComposites is not supported\n";
                 }
@@ -3452,8 +3452,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderSMBuiltinsFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(current);
+                const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(current);
                 if (enabling->shaderSMBuiltins && !supported.shaderSMBuiltins) {
                     ss << "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::shaderSMBuiltins is not supported\n";
                 }
@@ -3463,8 +3463,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderSplitBarrierFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *>(current);
+                const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT*>(current);
                 if (enabling->shaderSplitBarrier && !supported.shaderSplitBarrier) {
                     ss << "VkPhysicalDeviceShaderSplitBarrierFeaturesEXT::shaderSplitBarrier is not supported\n";
                 }
@@ -3474,8 +3474,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(current);
+                const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(current);
                 if (enabling->shaderSubgroupExtendedTypes && !supported.shaderSubgroupExtendedTypes) {
                     ss << "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::shaderSubgroupExtendedTypes is not supported\n";
                 }
@@ -3485,8 +3485,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *>(current);
+                const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*>(current);
                 if (enabling->shaderSubgroupPartitioned && !supported.shaderSubgroupPartitioned) {
                     ss << "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT::shaderSubgroupPartitioned is not supported\n";
                 }
@@ -3496,8 +3496,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderSubgroupRotateFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderSubgroupRotateFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures *>(current);
+                const VkPhysicalDeviceShaderSubgroupRotateFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures*>(current);
                 if (enabling->shaderSubgroupRotate && !supported.shaderSubgroupRotate) {
                     ss << "VkPhysicalDeviceShaderSubgroupRotateFeatures::shaderSubgroupRotate is not supported\n";
                 }
@@ -3510,8 +3510,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>(current);
+                const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(current);
                 if (enabling->shaderSubgroupUniformControlFlow && !supported.shaderSubgroupUniformControlFlow) {
                     ss << "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::shaderSubgroupUniformControlFlow is not "
                           "supported\n";
@@ -3522,8 +3522,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderTerminateInvocationFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderTerminateInvocationFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures *>(current);
+                const VkPhysicalDeviceShaderTerminateInvocationFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(current);
                 if (enabling->shaderTerminateInvocation && !supported.shaderTerminateInvocation) {
                     ss << "VkPhysicalDeviceShaderTerminateInvocationFeatures::shaderTerminateInvocation is not supported\n";
                 }
@@ -3533,8 +3533,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderTileImageFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderTileImageFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT *>(current);
+                const VkPhysicalDeviceShaderTileImageFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(current);
                 if (enabling->shaderTileImageColorReadAccess && !supported.shaderTileImageColorReadAccess) {
                     ss << "VkPhysicalDeviceShaderTileImageFeaturesEXT::shaderTileImageColorReadAccess is not supported\n";
                 }
@@ -3550,8 +3550,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT *>(current);
+                const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT*>(current);
                 if (enabling->shaderUniformBufferUnsizedArray && !supported.shaderUniformBufferUnsizedArray) {
                     ss << "VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT::shaderUniformBufferUnsizedArray is not "
                           "supported\n";
@@ -3562,8 +3562,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShaderUntypedPointersFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *>(current);
+                const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR*>(current);
                 if (enabling->shaderUntypedPointers && !supported.shaderUntypedPointers) {
                     ss << "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR::shaderUntypedPointers is not supported\n";
                 }
@@ -3573,8 +3573,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceShadingRateImageFeaturesNV supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceShadingRateImageFeaturesNV *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV *>(current);
+                const VkPhysicalDeviceShadingRateImageFeaturesNV* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(current);
                 if (enabling->shadingRateImage && !supported.shadingRateImage) {
                     ss << "VkPhysicalDeviceShadingRateImageFeaturesNV::shadingRateImage is not supported\n";
                 }
@@ -3587,8 +3587,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceSubgroupSizeControlFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceSubgroupSizeControlFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures *>(current);
+                const VkPhysicalDeviceSubgroupSizeControlFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(current);
                 if (enabling->subgroupSizeControl && !supported.subgroupSizeControl) {
                     ss << "VkPhysicalDeviceSubgroupSizeControlFeatures::subgroupSizeControl is not supported\n";
                 }
@@ -3601,8 +3601,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *>(current);
+                const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(current);
                 if (enabling->subpassMergeFeedback && !supported.subpassMergeFeedback) {
                     ss << "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::subpassMergeFeedback is not supported\n";
                 }
@@ -3612,8 +3612,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceSubpassShadingFeaturesHUAWEI supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>(current);
+                const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(current);
                 if (enabling->subpassShading && !supported.subpassShading) {
                     ss << "VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::subpassShading is not supported\n";
                 }
@@ -3623,8 +3623,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *>(current);
+                const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR*>(current);
                 if (enabling->swapchainMaintenance1 && !supported.swapchainMaintenance1) {
                     ss << "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR::swapchainMaintenance1 is not supported\n";
                 }
@@ -3634,8 +3634,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceSynchronization2Features supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceSynchronization2Features *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceSynchronization2Features *>(current);
+                const VkPhysicalDeviceSynchronization2Features* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(current);
                 if (enabling->synchronization2 && !supported.synchronization2) {
                     ss << "VkPhysicalDeviceSynchronization2Features::synchronization2 is not supported\n";
                 }
@@ -3645,8 +3645,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceTensorFeaturesARM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceTensorFeaturesARM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceTensorFeaturesARM *>(current);
+                const VkPhysicalDeviceTensorFeaturesARM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceTensorFeaturesARM*>(current);
                 if (enabling->tensorNonPacked && !supported.tensorNonPacked) {
                     ss << "VkPhysicalDeviceTensorFeaturesARM::tensorNonPacked is not supported\n";
                 }
@@ -3672,8 +3672,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(current);
+                const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(current);
                 if (enabling->texelBufferAlignment && !supported.texelBufferAlignment) {
                     ss << "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::texelBufferAlignment is not supported\n";
                 }
@@ -3683,8 +3683,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *>(current);
+                const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT*>(current);
                 if (enabling->textureCompressionASTC_3D && !supported.textureCompressionASTC_3D) {
                     ss << "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT::textureCompressionASTC_3D is not supported\n";
                 }
@@ -3694,8 +3694,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceTextureCompressionASTCHDRFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *>(current);
+                const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(current);
                 if (enabling->textureCompressionASTC_HDR && !supported.textureCompressionASTC_HDR) {
                     ss << "VkPhysicalDeviceTextureCompressionASTCHDRFeatures::textureCompressionASTC_HDR is not supported\n";
                 }
@@ -3705,8 +3705,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceThrottleHintFeaturesSEC supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceThrottleHintFeaturesSEC *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceThrottleHintFeaturesSEC *>(current);
+                const VkPhysicalDeviceThrottleHintFeaturesSEC* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceThrottleHintFeaturesSEC*>(current);
                 if (enabling->throttleHint && !supported.throttleHint) {
                     ss << "VkPhysicalDeviceThrottleHintFeaturesSEC::throttleHint is not supported\n";
                 }
@@ -3716,8 +3716,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceTileMemoryHeapFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *>(current);
+                const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*>(current);
                 if (enabling->tileMemoryHeap && !supported.tileMemoryHeap) {
                     ss << "VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::tileMemoryHeap is not supported\n";
                 }
@@ -3727,8 +3727,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceTilePropertiesFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceTilePropertiesFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM *>(current);
+                const VkPhysicalDeviceTilePropertiesFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(current);
                 if (enabling->tileProperties && !supported.tileProperties) {
                     ss << "VkPhysicalDeviceTilePropertiesFeaturesQCOM::tileProperties is not supported\n";
                 }
@@ -3738,8 +3738,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceTileShadingFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceTileShadingFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM *>(current);
+                const VkPhysicalDeviceTileShadingFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM*>(current);
                 if (enabling->tileShading && !supported.tileShading) {
                     ss << "VkPhysicalDeviceTileShadingFeaturesQCOM::tileShading is not supported\n";
                 }
@@ -3788,8 +3788,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceTimelineSemaphoreFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceTimelineSemaphoreFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures *>(current);
+                const VkPhysicalDeviceTimelineSemaphoreFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(current);
                 if (enabling->timelineSemaphore && !supported.timelineSemaphore) {
                     ss << "VkPhysicalDeviceTimelineSemaphoreFeatures::timelineSemaphore is not supported\n";
                 }
@@ -3799,8 +3799,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceTransformFeedbackFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceTransformFeedbackFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(current);
+                const VkPhysicalDeviceTransformFeedbackFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(current);
                 if (enabling->transformFeedback && !supported.transformFeedback) {
                     ss << "VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback is not supported\n";
                 }
@@ -3813,8 +3813,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *>(current);
+                const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*>(current);
                 if (enabling->unifiedImageLayouts && !supported.unifiedImageLayouts) {
                     ss << "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::unifiedImageLayouts is not supported\n";
                 }
@@ -3827,8 +3827,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceUniformBufferStandardLayoutFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(current);
+                const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(current);
                 if (enabling->uniformBufferStandardLayout && !supported.uniformBufferStandardLayout) {
                     ss << "VkPhysicalDeviceUniformBufferStandardLayoutFeatures::uniformBufferStandardLayout is not supported\n";
                 }
@@ -3838,8 +3838,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVariablePointersFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVariablePointersFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures *>(current);
+                const VkPhysicalDeviceVariablePointersFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(current);
                 if (enabling->variablePointersStorageBuffer && !supported.variablePointersStorageBuffer) {
                     ss << "VkPhysicalDeviceVariablePointersFeatures::variablePointersStorageBuffer is not supported\n";
                 }
@@ -3852,8 +3852,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVertexAttributeDivisorFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVertexAttributeDivisorFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures *>(current);
+                const VkPhysicalDeviceVertexAttributeDivisorFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures*>(current);
                 if (enabling->vertexAttributeInstanceRateDivisor && !supported.vertexAttributeInstanceRateDivisor) {
                     ss << "VkPhysicalDeviceVertexAttributeDivisorFeatures::vertexAttributeInstanceRateDivisor is not supported\n";
                 }
@@ -3867,8 +3867,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(current);
+                const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*>(current);
                 if (enabling->vertexAttributeRobustness && !supported.vertexAttributeRobustness) {
                     ss << "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::vertexAttributeRobustness is not supported\n";
                 }
@@ -3878,8 +3878,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>(current);
+                const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(current);
                 if (enabling->vertexInputDynamicState && !supported.vertexInputDynamicState) {
                     ss << "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::vertexInputDynamicState is not supported\n";
                 }
@@ -3889,8 +3889,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVideoDecodeVP9FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *>(current);
+                const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*>(current);
                 if (enabling->videoDecodeVP9 && !supported.videoDecodeVP9) {
                     ss << "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::videoDecodeVP9 is not supported\n";
                 }
@@ -3900,8 +3900,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVideoEncodeAV1FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *>(current);
+                const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*>(current);
                 if (enabling->videoEncodeAV1 && !supported.videoEncodeAV1) {
                     ss << "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::videoEncodeAV1 is not supported\n";
                 }
@@ -3911,8 +3911,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR *>(current);
+                const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR*>(current);
                 if (enabling->videoEncodeFeedback2 && !supported.videoEncodeFeedback2) {
                     ss << "VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR::videoEncodeFeedback2 is not supported\n";
                 }
@@ -3922,8 +3922,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *>(current);
+                const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR*>(current);
                 if (enabling->videoEncodeIntraRefresh && !supported.videoEncodeIntraRefresh) {
                     ss << "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR::videoEncodeIntraRefresh is not supported\n";
                 }
@@ -3933,8 +3933,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *>(current);
+                const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*>(current);
                 if (enabling->videoEncodeQuantizationMap && !supported.videoEncodeQuantizationMap) {
                     ss << "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR::videoEncodeQuantizationMap is not supported\n";
                 }
@@ -3944,8 +3944,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *>(current);
+                const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE*>(current);
                 if (enabling->videoEncodeRgbConversion && !supported.videoEncodeRgbConversion) {
                     ss << "VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::videoEncodeRgbConversion is not supported\n";
                 }
@@ -3955,8 +3955,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVideoMaintenance1FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(current);
+                const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR*>(current);
                 if (enabling->videoMaintenance1 && !supported.videoMaintenance1) {
                     ss << "VkPhysicalDeviceVideoMaintenance1FeaturesKHR::videoMaintenance1 is not supported\n";
                 }
@@ -3966,8 +3966,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVideoMaintenance2FeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *>(current);
+                const VkPhysicalDeviceVideoMaintenance2FeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR*>(current);
                 if (enabling->videoMaintenance2 && !supported.videoMaintenance2) {
                     ss << "VkPhysicalDeviceVideoMaintenance2FeaturesKHR::videoMaintenance2 is not supported\n";
                 }
@@ -3977,8 +3977,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVulkan11Features supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVulkan11Features *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVulkan11Features *>(current);
+                const VkPhysicalDeviceVulkan11Features* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(current);
                 if (enabling->storageBuffer16BitAccess && !supported.storageBuffer16BitAccess) {
                     ss << "VkPhysicalDeviceVulkan11Features::storageBuffer16BitAccess is not supported\n";
                 }
@@ -4021,8 +4021,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVulkan12Features supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVulkan12Features *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVulkan12Features *>(current);
+                const VkPhysicalDeviceVulkan12Features* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(current);
                 if (enabling->samplerMirrorClampToEdge && !supported.samplerMirrorClampToEdge) {
                     ss << "VkPhysicalDeviceVulkan12Features::samplerMirrorClampToEdge is not supported\n";
                 }
@@ -4182,8 +4182,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVulkan13Features supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVulkan13Features *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVulkan13Features *>(current);
+                const VkPhysicalDeviceVulkan13Features* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(current);
                 if (enabling->robustImageAccess && !supported.robustImageAccess) {
                     ss << "VkPhysicalDeviceVulkan13Features::robustImageAccess is not supported\n";
                 }
@@ -4236,8 +4236,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVulkan14Features supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVulkan14Features *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVulkan14Features *>(current);
+                const VkPhysicalDeviceVulkan14Features* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVulkan14Features*>(current);
                 if (enabling->globalPriorityQuery && !supported.globalPriorityQuery) {
                     ss << "VkPhysicalDeviceVulkan14Features::globalPriorityQuery is not supported\n";
                 }
@@ -4307,8 +4307,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVulkanMemoryModelFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVulkanMemoryModelFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures *>(current);
+                const VkPhysicalDeviceVulkanMemoryModelFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(current);
                 if (enabling->vulkanMemoryModel && !supported.vulkanMemoryModel) {
                     ss << "VkPhysicalDeviceVulkanMemoryModelFeatures::vulkanMemoryModel is not supported\n";
                 }
@@ -4326,8 +4326,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceVulkanSC10Features supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceVulkanSC10Features *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceVulkanSC10Features *>(current);
+                const VkPhysicalDeviceVulkanSC10Features* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceVulkanSC10Features*>(current);
                 if (enabling->shaderAtomicInstructions && !supported.shaderAtomicInstructions) {
                     ss << "VkPhysicalDeviceVulkanSC10Features::shaderAtomicInstructions is not supported\n";
                 }
@@ -4337,8 +4337,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(current);
+                const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(current);
                 if (enabling->workgroupMemoryExplicitLayout && !supported.workgroupMemoryExplicitLayout) {
                     ss << "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::workgroupMemoryExplicitLayout is not "
                           "supported\n";
@@ -4362,8 +4362,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>(current);
+                const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(current);
                 if (enabling->ycbcr2plane444Formats && !supported.ycbcr2plane444Formats) {
                     ss << "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::ycbcr2plane444Formats is not supported\n";
                 }
@@ -4373,8 +4373,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceYcbcrDegammaFeaturesQCOM supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *>(current);
+                const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*>(current);
                 if (enabling->ycbcrDegamma && !supported.ycbcrDegamma) {
                     ss << "VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::ycbcrDegamma is not supported\n";
                 }
@@ -4384,8 +4384,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceYcbcrImageArraysFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(current);
+                const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(current);
                 if (enabling->ycbcrImageArrays && !supported.ycbcrImageArrays) {
                     ss << "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::ycbcrImageArrays is not supported\n";
                 }
@@ -4395,8 +4395,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *>(current);
+                const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT*>(current);
                 if (enabling->zeroInitializeDeviceMemory && !supported.zeroInitializeDeviceMemory) {
                     ss << "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT::zeroInitializeDeviceMemory is not supported\n";
                 }
@@ -4406,8 +4406,8 @@ void DispatchInstance::ReportErrorFeatureNotPresent(VkPhysicalDevice gpu, const
                 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures supported = vku::InitStructHelper();
                 features_2.pNext = &supported;
                 DispatchGetPhysicalDeviceFeatures2(gpu, &features_2);
-                const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *enabling =
-                    reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *>(current);
+                const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* enabling =
+                    reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(current);
                 if (enabling->shaderZeroInitializeWorkgroupMemory && !supported.shaderZeroInitializeWorkgroupMemory) {
                     ss << "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::shaderZeroInitializeWorkgroupMemory is not "
                           "supported\n";
diff --git a/layers/vulkansc/generated/feature_requirements_helper.cpp b/layers/vulkansc/generated/feature_requirements_helper.cpp
index 5b0d4cc84..30e10763c 100644
--- a/layers/vulkansc/generated/feature_requirements_helper.cpp
+++ b/layers/vulkansc/generated/feature_requirements_helper.cpp
@@ -29,11 +29,11 @@
 #include <vulkan/utility/vk_struct_helper.hpp>
 
 namespace vkt {
-FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **inout_pnext_chain) {
+FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void** inout_pnext_chain) {
     switch (feature) {
         case Feature::storageBuffer16BitAccess:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan11Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan11Features;
@@ -46,7 +46,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->storageBuffer16BitAccess, "VkPhysicalDeviceVulkan11Features::storageBuffer16BitAccess"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDevice16BitStorageFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDevice16BitStorageFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDevice16BitStorageFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDevice16BitStorageFeatures;
@@ -61,7 +61,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::storageInputOutput16:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan11Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan11Features;
@@ -74,7 +74,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->storageInputOutput16, "VkPhysicalDeviceVulkan11Features::storageInputOutput16"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDevice16BitStorageFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDevice16BitStorageFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDevice16BitStorageFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDevice16BitStorageFeatures;
@@ -89,7 +89,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::storagePushConstant16:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan11Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan11Features;
@@ -102,7 +102,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->storagePushConstant16, "VkPhysicalDeviceVulkan11Features::storagePushConstant16"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDevice16BitStorageFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDevice16BitStorageFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDevice16BitStorageFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDevice16BitStorageFeatures;
@@ -117,7 +117,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::uniformAndStorageBuffer16BitAccess:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan11Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan11Features;
@@ -131,7 +131,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->uniformAndStorageBuffer16BitAccess,
                         "VkPhysicalDeviceVulkan11Features::uniformAndStorageBuffer16BitAccess"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDevice16BitStorageFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDevice16BitStorageFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDevice16BitStorageFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDevice16BitStorageFeatures;
@@ -146,7 +146,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDevice16BitStorageFeatures::uniformAndStorageBuffer16BitAccess"};
             }
         case Feature::formatA4B4G4R4: {
-            auto vk_struct = const_cast<VkPhysicalDevice4444FormatsFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevice4444FormatsFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevice4444FormatsFeaturesEXT;
@@ -161,7 +161,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::formatA4R4G4B4: {
-            auto vk_struct = const_cast<VkPhysicalDevice4444FormatsFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevice4444FormatsFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevice4444FormatsFeaturesEXT;
@@ -177,7 +177,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::storageBuffer8BitAccess:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -190,7 +190,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->storageBuffer8BitAccess, "VkPhysicalDeviceVulkan12Features::storageBuffer8BitAccess"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDevice8BitStorageFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDevice8BitStorageFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDevice8BitStorageFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDevice8BitStorageFeatures;
@@ -205,7 +205,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::storagePushConstant8:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -218,7 +218,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->storagePushConstant8, "VkPhysicalDeviceVulkan12Features::storagePushConstant8"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDevice8BitStorageFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDevice8BitStorageFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDevice8BitStorageFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDevice8BitStorageFeatures;
@@ -233,7 +233,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::uniformAndStorageBuffer8BitAccess:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -247,7 +247,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->uniformAndStorageBuffer8BitAccess,
                         "VkPhysicalDeviceVulkan12Features::uniformAndStorageBuffer8BitAccess"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDevice8BitStorageFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDevice8BitStorageFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDevice8BitStorageFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDevice8BitStorageFeatures;
@@ -262,7 +262,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDevice8BitStorageFeatures::uniformAndStorageBuffer8BitAccess"};
             }
         case Feature::decodeModeSharedExponent: {
-            auto vk_struct = const_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceASTCDecodeFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceASTCDecodeFeaturesEXT;
@@ -277,7 +277,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::accelerationStructure: {
-            auto vk_struct = const_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceAccelerationStructureFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceAccelerationStructureFeaturesKHR;
@@ -292,7 +292,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::accelerationStructureCaptureReplay: {
-            auto vk_struct = const_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceAccelerationStructureFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceAccelerationStructureFeaturesKHR;
@@ -308,7 +308,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::accelerationStructureHostCommands: {
-            auto vk_struct = const_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceAccelerationStructureFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceAccelerationStructureFeaturesKHR;
@@ -324,7 +324,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::accelerationStructureIndirectBuild: {
-            auto vk_struct = const_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceAccelerationStructureFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceAccelerationStructureFeaturesKHR;
@@ -340,7 +340,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::descriptorBindingAccelerationStructureUpdateAfterBind: {
-            auto vk_struct = const_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceAccelerationStructureFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceAccelerationStructureFeaturesKHR;
@@ -356,7 +356,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::reportAddressBinding: {
-            auto vk_struct = const_cast<VkPhysicalDeviceAddressBindingReportFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceAddressBindingReportFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceAddressBindingReportFeaturesEXT;
@@ -371,7 +371,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::amigoProfiling: {
-            auto vk_struct = const_cast<VkPhysicalDeviceAmigoProfilingFeaturesSEC *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceAmigoProfilingFeaturesSEC>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceAmigoProfilingFeaturesSEC;
@@ -386,7 +386,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::antiLag: {
-            auto vk_struct = const_cast<VkPhysicalDeviceAntiLagFeaturesAMD *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceAntiLagFeaturesAMD*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceAntiLagFeaturesAMD>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceAntiLagFeaturesAMD;
@@ -401,7 +401,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::attachmentFeedbackLoopDynamicState: {
-            auto vk_struct = const_cast<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
@@ -417,7 +417,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::attachmentFeedbackLoopLayout: {
-            auto vk_struct = const_cast<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
@@ -433,7 +433,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::advancedBlendCoherentOperations: {
-            auto vk_struct = const_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
@@ -449,7 +449,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::borderColorSwizzle: {
-            auto vk_struct = const_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceBorderColorSwizzleFeaturesEXT;
@@ -464,7 +464,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::borderColorSwizzleFromImage: {
-            auto vk_struct = const_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceBorderColorSwizzleFeaturesEXT;
@@ -481,7 +481,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::bufferDeviceAddress:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -494,7 +494,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->bufferDeviceAddress, "VkPhysicalDeviceVulkan12Features::bufferDeviceAddress"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceBufferDeviceAddressFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceBufferDeviceAddressFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceBufferDeviceAddressFeatures;
@@ -509,7 +509,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::bufferDeviceAddressCaptureReplay:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -523,7 +523,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->bufferDeviceAddressCaptureReplay,
                         "VkPhysicalDeviceVulkan12Features::bufferDeviceAddressCaptureReplay"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceBufferDeviceAddressFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceBufferDeviceAddressFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceBufferDeviceAddressFeatures;
@@ -539,7 +539,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::bufferDeviceAddressMultiDevice:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -553,7 +553,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->bufferDeviceAddressMultiDevice,
                         "VkPhysicalDeviceVulkan12Features::bufferDeviceAddressMultiDevice"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceBufferDeviceAddressFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceBufferDeviceAddressFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceBufferDeviceAddressFeatures;
@@ -568,7 +568,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddressMultiDevice"};
             }
         case Feature::clusterAccelerationStructure: {
-            auto vk_struct = const_cast<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceClusterAccelerationStructureFeaturesNV;
@@ -584,7 +584,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::clustercullingShader: {
-            auto vk_struct = const_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI;
@@ -599,7 +599,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::multiviewClusterCullingShader: {
-            auto vk_struct = const_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI;
@@ -615,7 +615,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::deviceCoherentMemory: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCoherentMemoryFeaturesAMD;
@@ -630,7 +630,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::colorWriteEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceColorWriteEnableFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceColorWriteEnableFeaturesEXT;
@@ -645,7 +645,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::commandBufferInheritance: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCommandBufferInheritanceFeaturesNV;
@@ -661,7 +661,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::computeOccupancyPriority: {
-            auto vk_struct = const_cast<VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV;
@@ -677,7 +677,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::computeDerivativeGroupLinear: {
-            auto vk_struct = const_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR;
@@ -693,7 +693,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::computeDerivativeGroupQuads: {
-            auto vk_struct = const_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR;
@@ -709,7 +709,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::conditionalRendering: {
-            auto vk_struct = const_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceConditionalRenderingFeaturesEXT;
@@ -724,7 +724,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::inheritedConditionalRendering: {
-            auto vk_struct = const_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceConditionalRenderingFeaturesEXT;
@@ -740,7 +740,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cooperativeMatrixBlockLoads: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCooperativeMatrix2FeaturesNV;
@@ -756,7 +756,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cooperativeMatrixConversions: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCooperativeMatrix2FeaturesNV;
@@ -772,7 +772,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cooperativeMatrixFlexibleDimensions: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCooperativeMatrix2FeaturesNV;
@@ -788,7 +788,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cooperativeMatrixPerElementOperations: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCooperativeMatrix2FeaturesNV;
@@ -804,7 +804,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cooperativeMatrixReductions: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCooperativeMatrix2FeaturesNV;
@@ -820,7 +820,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cooperativeMatrixTensorAddressing: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCooperativeMatrix2FeaturesNV;
@@ -836,7 +836,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cooperativeMatrixWorkgroupScope: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCooperativeMatrix2FeaturesNV;
@@ -852,7 +852,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cooperativeMatrixConversion: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM;
@@ -868,7 +868,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cooperativeMatrixDecodeVector: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV;
@@ -884,7 +884,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cooperativeMatrix: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrixFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCooperativeMatrixFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCooperativeMatrixFeaturesKHR;
@@ -899,7 +899,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cooperativeMatrixRobustBufferAccess: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeMatrixFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCooperativeMatrixFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCooperativeMatrixFeaturesKHR;
@@ -915,7 +915,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cooperativeVector: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeVectorFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeVectorFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCooperativeVectorFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCooperativeVectorFeaturesNV;
@@ -930,7 +930,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cooperativeVectorTraining: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeVectorFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCooperativeVectorFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCooperativeVectorFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCooperativeVectorFeaturesNV;
@@ -946,7 +946,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::indirectMemoryCopy: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR;
@@ -961,7 +961,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::indirectMemoryToImageCopy: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR;
@@ -977,7 +977,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::indirectCopy: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCopyMemoryIndirectFeaturesNV;
@@ -992,7 +992,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cornerSampledImage: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCornerSampledImageFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCornerSampledImageFeaturesNV;
@@ -1007,7 +1007,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::coverageReductionMode: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCoverageReductionModeFeaturesNV;
@@ -1022,7 +1022,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::cubicRangeClamp: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCubicClampFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCubicClampFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCubicClampFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCubicClampFeaturesQCOM;
@@ -1037,7 +1037,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::selectableCubicWeights: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCubicWeightsFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCubicWeightsFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCubicWeightsFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCubicWeightsFeaturesQCOM;
@@ -1053,7 +1053,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::cudaKernelLaunchFeatures: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCudaKernelLaunchFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCudaKernelLaunchFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCudaKernelLaunchFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCudaKernelLaunchFeaturesNV;
@@ -1069,7 +1069,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::customBorderColorWithoutFormat: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCustomBorderColorFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCustomBorderColorFeaturesEXT;
@@ -1085,7 +1085,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::customBorderColors: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCustomBorderColorFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCustomBorderColorFeaturesEXT;
@@ -1100,7 +1100,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::customResolve: {
-            auto vk_struct = const_cast<VkPhysicalDeviceCustomResolveFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceCustomResolveFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceCustomResolveFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceCustomResolveFeaturesEXT;
@@ -1115,7 +1115,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::dataGraph: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDataGraphFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDataGraphFeaturesARM;
@@ -1130,7 +1130,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::dataGraphDescriptorBuffer: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDataGraphFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDataGraphFeaturesARM;
@@ -1145,7 +1145,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::dataGraphShaderModule: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDataGraphFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDataGraphFeaturesARM;
@@ -1160,7 +1160,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::dataGraphSpecializationConstants: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDataGraphFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDataGraphFeaturesARM;
@@ -1176,7 +1176,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::dataGraphUpdateAfterBind: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDataGraphFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDataGraphFeaturesARM;
@@ -1191,7 +1191,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::dataGraphModel: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphModelFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphModelFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDataGraphModelFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDataGraphModelFeaturesQCOM;
@@ -1206,7 +1206,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::dataGraphNeuralAcceleratorStatistics: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM;
@@ -1222,7 +1222,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::dataGraphOpticalFlow: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM;
@@ -1237,7 +1237,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::dedicatedAllocationImageAliasing: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
@@ -1254,7 +1254,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::denseGeometryFormat: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX;
@@ -1270,7 +1270,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::depthBiasControl: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDepthBiasControlFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDepthBiasControlFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDepthBiasControlFeaturesEXT;
@@ -1285,7 +1285,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::depthBiasExact: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDepthBiasControlFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDepthBiasControlFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDepthBiasControlFeaturesEXT;
@@ -1300,7 +1300,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::floatRepresentation: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDepthBiasControlFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDepthBiasControlFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDepthBiasControlFeaturesEXT;
@@ -1315,7 +1315,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::leastRepresentableValueForceUnormRepresentation: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDepthBiasControlFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDepthBiasControlFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDepthBiasControlFeaturesEXT;
@@ -1331,7 +1331,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::depthClampControl: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDepthClampControlFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDepthClampControlFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDepthClampControlFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDepthClampControlFeaturesEXT;
@@ -1346,7 +1346,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::depthClampZeroOne: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDepthClampZeroOneFeaturesKHR;
@@ -1361,7 +1361,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::depthClipControl: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDepthClipControlFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDepthClipControlFeaturesEXT;
@@ -1376,7 +1376,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::depthClipEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDepthClipEnableFeaturesEXT;
@@ -1391,7 +1391,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::descriptorBuffer: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorBufferFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDescriptorBufferFeaturesEXT;
@@ -1406,7 +1406,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::descriptorBufferCaptureReplay: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorBufferFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDescriptorBufferFeaturesEXT;
@@ -1422,7 +1422,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::descriptorBufferImageLayoutIgnored: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorBufferFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDescriptorBufferFeaturesEXT;
@@ -1438,7 +1438,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::descriptorBufferPushDescriptors: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorBufferFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDescriptorBufferFeaturesEXT;
@@ -1454,7 +1454,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::descriptorBufferTensorDescriptors: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorBufferTensorFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorBufferTensorFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDescriptorBufferTensorFeaturesARM;
@@ -1470,7 +1470,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::descriptorHeap: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorHeapFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorHeapFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorHeapFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDescriptorHeapFeaturesEXT;
@@ -1485,7 +1485,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::descriptorHeapCaptureReplay: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorHeapFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorHeapFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorHeapFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDescriptorHeapFeaturesEXT;
@@ -1502,7 +1502,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::descriptorBindingPartiallyBound:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1516,7 +1516,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->descriptorBindingPartiallyBound,
                         "VkPhysicalDeviceVulkan12Features::descriptorBindingPartiallyBound"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1532,7 +1532,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::descriptorBindingSampledImageUpdateAfterBind:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1546,7 +1546,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->descriptorBindingSampledImageUpdateAfterBind,
                         "VkPhysicalDeviceVulkan12Features::descriptorBindingSampledImageUpdateAfterBind"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1562,7 +1562,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::descriptorBindingStorageBufferUpdateAfterBind:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1576,7 +1576,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->descriptorBindingStorageBufferUpdateAfterBind,
                         "VkPhysicalDeviceVulkan12Features::descriptorBindingStorageBufferUpdateAfterBind"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1592,7 +1592,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::descriptorBindingStorageImageUpdateAfterBind:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1606,7 +1606,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->descriptorBindingStorageImageUpdateAfterBind,
                         "VkPhysicalDeviceVulkan12Features::descriptorBindingStorageImageUpdateAfterBind"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1622,7 +1622,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::descriptorBindingStorageTexelBufferUpdateAfterBind:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1636,7 +1636,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->descriptorBindingStorageTexelBufferUpdateAfterBind,
                         "VkPhysicalDeviceVulkan12Features::descriptorBindingStorageTexelBufferUpdateAfterBind"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1652,7 +1652,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::descriptorBindingUniformBufferUpdateAfterBind:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1666,7 +1666,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->descriptorBindingUniformBufferUpdateAfterBind,
                         "VkPhysicalDeviceVulkan12Features::descriptorBindingUniformBufferUpdateAfterBind"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1682,7 +1682,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::descriptorBindingUniformTexelBufferUpdateAfterBind:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1696,7 +1696,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->descriptorBindingUniformTexelBufferUpdateAfterBind,
                         "VkPhysicalDeviceVulkan12Features::descriptorBindingUniformTexelBufferUpdateAfterBind"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1712,7 +1712,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::descriptorBindingUpdateUnusedWhilePending:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1726,7 +1726,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->descriptorBindingUpdateUnusedWhilePending,
                         "VkPhysicalDeviceVulkan12Features::descriptorBindingUpdateUnusedWhilePending"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1742,7 +1742,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::descriptorBindingVariableDescriptorCount:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1756,7 +1756,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->descriptorBindingVariableDescriptorCount,
                         "VkPhysicalDeviceVulkan12Features::descriptorBindingVariableDescriptorCount"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1772,7 +1772,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::runtimeDescriptorArray:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1785,7 +1785,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->runtimeDescriptorArray, "VkPhysicalDeviceVulkan12Features::runtimeDescriptorArray"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1800,7 +1800,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderInputAttachmentArrayDynamicIndexing:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1814,7 +1814,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderInputAttachmentArrayDynamicIndexing,
                         "VkPhysicalDeviceVulkan12Features::shaderInputAttachmentArrayDynamicIndexing"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1830,7 +1830,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderInputAttachmentArrayNonUniformIndexing:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1844,7 +1844,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderInputAttachmentArrayNonUniformIndexing,
                         "VkPhysicalDeviceVulkan12Features::shaderInputAttachmentArrayNonUniformIndexing"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1860,7 +1860,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderSampledImageArrayNonUniformIndexing:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1874,7 +1874,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderSampledImageArrayNonUniformIndexing,
                         "VkPhysicalDeviceVulkan12Features::shaderSampledImageArrayNonUniformIndexing"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1890,7 +1890,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderStorageBufferArrayNonUniformIndexing:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1904,7 +1904,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderStorageBufferArrayNonUniformIndexing,
                         "VkPhysicalDeviceVulkan12Features::shaderStorageBufferArrayNonUniformIndexing"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1920,7 +1920,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderStorageImageArrayNonUniformIndexing:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1934,7 +1934,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderStorageImageArrayNonUniformIndexing,
                         "VkPhysicalDeviceVulkan12Features::shaderStorageImageArrayNonUniformIndexing"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1950,7 +1950,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderStorageTexelBufferArrayDynamicIndexing:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1964,7 +1964,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderStorageTexelBufferArrayDynamicIndexing,
                         "VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayDynamicIndexing"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -1980,7 +1980,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderStorageTexelBufferArrayNonUniformIndexing:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -1994,7 +1994,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderStorageTexelBufferArrayNonUniformIndexing,
                         "VkPhysicalDeviceVulkan12Features::shaderStorageTexelBufferArrayNonUniformIndexing"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -2010,7 +2010,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderUniformBufferArrayNonUniformIndexing:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -2024,7 +2024,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderUniformBufferArrayNonUniformIndexing,
                         "VkPhysicalDeviceVulkan12Features::shaderUniformBufferArrayNonUniformIndexing"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -2040,7 +2040,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderUniformTexelBufferArrayDynamicIndexing:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -2054,7 +2054,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderUniformTexelBufferArrayDynamicIndexing,
                         "VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayDynamicIndexing"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -2070,7 +2070,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderUniformTexelBufferArrayNonUniformIndexing:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -2084,7 +2084,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderUniformTexelBufferArrayNonUniformIndexing,
                         "VkPhysicalDeviceVulkan12Features::shaderUniformTexelBufferArrayNonUniformIndexing"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorIndexingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDescriptorIndexingFeatures;
@@ -2099,7 +2099,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDeviceDescriptorIndexingFeatures::shaderUniformTexelBufferArrayNonUniformIndexing"};
             }
         case Feature::descriptorPoolOverallocation: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
@@ -2115,7 +2115,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::descriptorSetHostMapping: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
@@ -2131,7 +2131,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::deviceAddressCommands: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR;
@@ -2146,7 +2146,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::deviceGeneratedCompute: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
@@ -2162,7 +2162,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::deviceGeneratedComputeCaptureReplay: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
@@ -2178,7 +2178,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::deviceGeneratedComputePipelines: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
@@ -2194,7 +2194,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::deviceGeneratedCommands: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT;
@@ -2210,7 +2210,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::dynamicGeneratedPipelineLayout: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT;
@@ -2226,7 +2226,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::deviceMemoryReport: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDeviceMemoryReportFeaturesEXT;
@@ -2241,7 +2241,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::diagnosticsConfig: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDiagnosticsConfigFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDiagnosticsConfigFeaturesNV;
@@ -2257,7 +2257,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::displacementMicromap: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDisplacementMicromapFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDisplacementMicromapFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDisplacementMicromapFeaturesNV;
@@ -2274,7 +2274,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::dynamicRendering:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -2287,7 +2287,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->dynamicRendering, "VkPhysicalDeviceVulkan13Features::dynamicRendering"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDynamicRenderingFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDynamicRenderingFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDynamicRenderingFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDynamicRenderingFeatures;
@@ -2302,7 +2302,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::dynamicRenderingLocalRead:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -2315,7 +2315,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->dynamicRenderingLocalRead, "VkPhysicalDeviceVulkan14Features::dynamicRenderingLocalRead"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceDynamicRenderingLocalReadFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceDynamicRenderingLocalReadFeatures;
@@ -2330,7 +2330,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDeviceDynamicRenderingLocalReadFeatures::dynamicRenderingLocalRead"};
             }
         case Feature::dynamicRenderingUnusedAttachments: {
-            auto vk_struct = const_cast<VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
@@ -2346,7 +2346,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::elapsedTimerQuery: {
-            auto vk_struct = const_cast<VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM;
@@ -2361,7 +2361,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::exclusiveScissor: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExclusiveScissorFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExclusiveScissorFeaturesNV;
@@ -2376,7 +2376,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState2: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState2FeaturesEXT;
@@ -2391,7 +2391,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState2LogicOp: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState2FeaturesEXT;
@@ -2407,7 +2407,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState2PatchControlPoints: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState2FeaturesEXT;
@@ -2423,7 +2423,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3AlphaToCoverageEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2439,7 +2439,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3AlphaToOneEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2455,7 +2455,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3ColorBlendAdvanced: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2471,7 +2471,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3ColorBlendEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2487,7 +2487,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3ColorBlendEquation: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2503,7 +2503,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3ColorWriteMask: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2519,7 +2519,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3ConservativeRasterizationMode: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2535,7 +2535,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3CoverageModulationMode: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2551,7 +2551,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3CoverageModulationTable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2567,7 +2567,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3CoverageModulationTableEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2583,7 +2583,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3CoverageReductionMode: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2599,7 +2599,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3CoverageToColorEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2615,7 +2615,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3CoverageToColorLocation: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2631,7 +2631,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3DepthClampEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2647,7 +2647,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3DepthClipEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2663,7 +2663,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3DepthClipNegativeOneToOne: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2679,7 +2679,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3ExtraPrimitiveOverestimationSize: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2695,7 +2695,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3LineRasterizationMode: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2711,7 +2711,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3LineStippleEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2727,7 +2727,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3LogicOpEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2743,7 +2743,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3PolygonMode: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2759,7 +2759,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3ProvokingVertexMode: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2775,7 +2775,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3RasterizationSamples: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2791,7 +2791,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3RasterizationStream: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2807,7 +2807,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3RepresentativeFragmentTestEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2823,7 +2823,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3SampleLocationsEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2839,7 +2839,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3SampleMask: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2855,7 +2855,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3ShadingRateImageEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2871,7 +2871,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3TessellationDomainOrigin: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2887,7 +2887,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3ViewportSwizzle: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2903,7 +2903,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState3ViewportWScalingEnable: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicState3FeaturesEXT;
@@ -2919,7 +2919,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedDynamicState: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedDynamicStateFeaturesEXT;
@@ -2934,7 +2934,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedFlags: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedFlagsFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedFlagsFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedFlagsFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedFlagsFeaturesKHR;
@@ -2949,7 +2949,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::extendedSparseAddressSpace: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
@@ -2966,7 +2966,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 
         case Feature::externalFormatResolve: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExternalFormatResolveFeaturesANDROID>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExternalFormatResolveFeaturesANDROID;
@@ -2983,7 +2983,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 
         case Feature::externalMemoryRDMA: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExternalMemoryRDMAFeaturesNV;
@@ -2999,7 +2999,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_USE_PLATFORM_SCI
 
         case Feature::sciBufExport: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExternalMemorySciBufFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExternalMemorySciBufFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExternalMemorySciBufFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExternalMemorySciBufFeaturesNV;
@@ -3016,7 +3016,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_USE_PLATFORM_SCI
 
         case Feature::sciBufImport: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExternalMemorySciBufFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExternalMemorySciBufFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExternalMemorySciBufFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExternalMemorySciBufFeaturesNV;
@@ -3033,7 +3033,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
 
         case Feature::screenBufferImport: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
@@ -3050,7 +3050,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_USE_PLATFORM_SCI
 
         case Feature::sciSyncSemaphore2: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExternalSciSync2FeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExternalSciSync2FeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExternalSciSync2FeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExternalSciSync2FeaturesNV;
@@ -3067,7 +3067,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_USE_PLATFORM_SCI
 
         case Feature::sciSyncExport: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExternalSciSync2FeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExternalSciSync2FeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExternalSciSync2FeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExternalSciSync2FeaturesNV;
@@ -3084,7 +3084,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_USE_PLATFORM_SCI
 
         case Feature::sciSyncFence: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExternalSciSync2FeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExternalSciSync2FeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExternalSciSync2FeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExternalSciSync2FeaturesNV;
@@ -3101,7 +3101,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_USE_PLATFORM_SCI
 
         case Feature::sciSyncImport: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExternalSciSync2FeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExternalSciSync2FeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExternalSciSync2FeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExternalSciSync2FeaturesNV;
@@ -3118,7 +3118,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_USE_PLATFORM_SCI
 
         case Feature::sciSyncSemaphore: {
-            auto vk_struct = const_cast<VkPhysicalDeviceExternalSciSyncFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceExternalSciSyncFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceExternalSciSyncFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceExternalSciSyncFeaturesNV;
@@ -3134,7 +3134,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #endif  // VK_USE_PLATFORM_SCI
 
         case Feature::deviceFault: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFaultFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFaultFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFaultFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFaultFeaturesKHR;
@@ -3149,7 +3149,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::deviceFaultDeviceLostOnMasked: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFaultFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFaultFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFaultFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFaultFeaturesKHR;
@@ -3164,7 +3164,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::deviceFaultReportMasked: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFaultFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFaultFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFaultFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFaultFeaturesKHR;
@@ -3179,7 +3179,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::deviceFaultVendorBinary: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFaultFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFaultFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFaultFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFaultFeaturesKHR;
@@ -3194,7 +3194,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::formatPack: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFormatPackFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFormatPackFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFormatPackFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFormatPackFeaturesARM;
@@ -3209,7 +3209,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::fragmentDensityMapDeferred: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentDensityMap2FeaturesEXT;
@@ -3225,7 +3225,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::fragmentDensityMap: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentDensityMapFeaturesEXT;
@@ -3240,7 +3240,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::fragmentDensityMapDynamic: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentDensityMapFeaturesEXT;
@@ -3256,7 +3256,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::fragmentDensityMapNonSubsampledImages: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentDensityMapFeaturesEXT;
@@ -3272,7 +3272,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::fragmentDensityMapLayered: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE;
@@ -3288,7 +3288,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::fragmentDensityMapOffset: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
@@ -3304,7 +3304,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::fragmentShaderBarycentric: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
@@ -3320,7 +3320,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::fragmentShaderPixelInterlock: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;
@@ -3336,7 +3336,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::fragmentShaderSampleInterlock: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;
@@ -3352,7 +3352,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::fragmentShaderShadingRateInterlock: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;
@@ -3368,7 +3368,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::fragmentShadingRateEnums: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
@@ -3384,7 +3384,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::noInvocationFragmentShadingRates: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
@@ -3400,7 +3400,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::supersampleFragmentShadingRates: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
@@ -3416,7 +3416,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::attachmentFragmentShadingRate: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentShadingRateFeaturesKHR;
@@ -3432,7 +3432,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::pipelineFragmentShadingRate: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentShadingRateFeaturesKHR;
@@ -3448,7 +3448,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::primitiveFragmentShadingRate: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFragmentShadingRateFeaturesKHR;
@@ -3464,7 +3464,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::frameBoundary: {
-            auto vk_struct = const_cast<VkPhysicalDeviceFrameBoundaryFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceFrameBoundaryFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceFrameBoundaryFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceFrameBoundaryFeaturesEXT;
@@ -3480,7 +3480,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::globalPriorityQuery:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -3493,7 +3493,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->globalPriorityQuery, "VkPhysicalDeviceVulkan14Features::globalPriorityQuery"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceGlobalPriorityQueryFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceGlobalPriorityQueryFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceGlobalPriorityQueryFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceGlobalPriorityQueryFeatures;
@@ -3507,7 +3507,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->globalPriorityQuery, "VkPhysicalDeviceGlobalPriorityQueryFeatures::globalPriorityQuery"};
             }
         case Feature::clockModes: {
-            auto vk_struct = const_cast<VkPhysicalDeviceGpaFeaturesAMD *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceGpaFeaturesAMD*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceGpaFeaturesAMD>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceGpaFeaturesAMD;
@@ -3522,7 +3522,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::perfCounters: {
-            auto vk_struct = const_cast<VkPhysicalDeviceGpaFeaturesAMD *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceGpaFeaturesAMD*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceGpaFeaturesAMD>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceGpaFeaturesAMD;
@@ -3537,7 +3537,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::sqThreadTracing: {
-            auto vk_struct = const_cast<VkPhysicalDeviceGpaFeaturesAMD *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceGpaFeaturesAMD*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceGpaFeaturesAMD>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceGpaFeaturesAMD;
@@ -3552,7 +3552,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::streamingPerfCounters: {
-            auto vk_struct = const_cast<VkPhysicalDeviceGpaFeaturesAMD *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceGpaFeaturesAMD*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceGpaFeaturesAMD>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceGpaFeaturesAMD;
@@ -3567,7 +3567,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::graphicsPipelineLibrary: {
-            auto vk_struct = const_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;
@@ -3583,7 +3583,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::hdrVivid: {
-            auto vk_struct = const_cast<VkPhysicalDeviceHdrVividFeaturesHUAWEI *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceHdrVividFeaturesHUAWEI*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceHdrVividFeaturesHUAWEI>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceHdrVividFeaturesHUAWEI;
@@ -3599,7 +3599,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::hostImageCopy:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -3612,7 +3612,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->hostImageCopy, "VkPhysicalDeviceVulkan14Features::hostImageCopy"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceHostImageCopyFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceHostImageCopyFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceHostImageCopyFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceHostImageCopyFeatures;
@@ -3627,7 +3627,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::hostQueryReset:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -3640,7 +3640,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->hostQueryReset, "VkPhysicalDeviceVulkan12Features::hostQueryReset"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceHostQueryResetFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceHostQueryResetFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceHostQueryResetFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceHostQueryResetFeatures;
@@ -3654,7 +3654,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->hostQueryReset, "VkPhysicalDeviceHostQueryResetFeatures::hostQueryReset"};
             }
         case Feature::image2DViewOf3D: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImage2DViewOf3DFeaturesEXT;
@@ -3669,7 +3669,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::sampler2DViewOf3D: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImage2DViewOf3DFeaturesEXT;
@@ -3684,7 +3684,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::imageAlignmentControl: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImageAlignmentControlFeaturesMESA *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImageAlignmentControlFeaturesMESA*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImageAlignmentControlFeaturesMESA>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImageAlignmentControlFeaturesMESA;
@@ -3699,7 +3699,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::imageCompressionControl: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImageCompressionControlFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImageCompressionControlFeaturesEXT;
@@ -3715,7 +3715,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::imageCompressionControlSwapchain: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
@@ -3731,7 +3731,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::textureBlockMatch2: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessing2FeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessing2FeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImageProcessing2FeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImageProcessing2FeaturesQCOM;
@@ -3746,7 +3746,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::blockMatchExtendedClampToEdge: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessing3FeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessing3FeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImageProcessing3FeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImageProcessing3FeaturesQCOM;
@@ -3762,7 +3762,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::imageGatherExtendedModes: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessing3FeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessing3FeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImageProcessing3FeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImageProcessing3FeaturesQCOM;
@@ -3777,7 +3777,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::imageGatherLinear: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessing3FeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessing3FeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImageProcessing3FeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImageProcessing3FeaturesQCOM;
@@ -3792,7 +3792,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::textureBlockMatch: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImageProcessingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImageProcessingFeaturesQCOM;
@@ -3807,7 +3807,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::textureBoxFilter: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImageProcessingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImageProcessingFeaturesQCOM;
@@ -3822,7 +3822,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::textureSampleWeighted: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImageProcessingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImageProcessingFeaturesQCOM;
@@ -3838,7 +3838,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::robustImageAccess:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -3851,7 +3851,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->robustImageAccess, "VkPhysicalDeviceVulkan13Features::robustImageAccess"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceImageRobustnessFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceImageRobustnessFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceImageRobustnessFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceImageRobustnessFeatures;
@@ -3865,7 +3865,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->robustImageAccess, "VkPhysicalDeviceImageRobustnessFeatures::robustImageAccess"};
             }
         case Feature::imageSlicedViewOf3D: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
@@ -3880,7 +3880,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::minLod: {
-            auto vk_struct = const_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceImageViewMinLodFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceImageViewMinLodFeaturesEXT;
@@ -3896,7 +3896,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::imagelessFramebuffer:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -3909,7 +3909,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->imagelessFramebuffer, "VkPhysicalDeviceVulkan12Features::imagelessFramebuffer"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceImagelessFramebufferFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceImagelessFramebufferFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceImagelessFramebufferFeatures;
@@ -3924,7 +3924,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::indexTypeUint8:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -3937,7 +3937,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->indexTypeUint8, "VkPhysicalDeviceVulkan14Features::indexTypeUint8"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceIndexTypeUint8Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceIndexTypeUint8Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceIndexTypeUint8Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceIndexTypeUint8Features;
@@ -3951,7 +3951,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->indexTypeUint8, "VkPhysicalDeviceIndexTypeUint8Features::indexTypeUint8"};
             }
         case Feature::inheritedViewportScissor2D: {
-            auto vk_struct = const_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceInheritedViewportScissorFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceInheritedViewportScissorFeaturesNV;
@@ -3968,7 +3968,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::descriptorBindingInlineUniformBlockUpdateAfterBind:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -3982,7 +3982,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->descriptorBindingInlineUniformBlockUpdateAfterBind,
                         "VkPhysicalDeviceVulkan13Features::descriptorBindingInlineUniformBlockUpdateAfterBind"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceInlineUniformBlockFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceInlineUniformBlockFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceInlineUniformBlockFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceInlineUniformBlockFeatures;
@@ -3998,7 +3998,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::inlineUniformBlock:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -4011,7 +4011,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->inlineUniformBlock, "VkPhysicalDeviceVulkan13Features::inlineUniformBlock"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceInlineUniformBlockFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceInlineUniformBlockFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceInlineUniformBlockFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceInlineUniformBlockFeatures;
@@ -4025,7 +4025,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->inlineUniformBlock, "VkPhysicalDeviceInlineUniformBlockFeatures::inlineUniformBlock"};
             }
         case Feature::internallySynchronizedQueues: {
-            auto vk_struct = const_cast<VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR;
@@ -4041,7 +4041,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::invocationMask: {
-            auto vk_struct = const_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceInvocationMaskFeaturesHUAWEI;
@@ -4056,7 +4056,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::legacyDithering: {
-            auto vk_struct = const_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceLegacyDitheringFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceLegacyDitheringFeaturesEXT;
@@ -4071,7 +4071,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::legacyVertexAttributes: {
-            auto vk_struct = const_cast<VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT;
@@ -4088,7 +4088,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::bresenhamLines:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -4101,7 +4101,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->bresenhamLines, "VkPhysicalDeviceVulkan14Features::bresenhamLines"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceLineRasterizationFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceLineRasterizationFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceLineRasterizationFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceLineRasterizationFeatures;
@@ -4116,7 +4116,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::rectangularLines:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -4129,7 +4129,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->rectangularLines, "VkPhysicalDeviceVulkan14Features::rectangularLines"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceLineRasterizationFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceLineRasterizationFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceLineRasterizationFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceLineRasterizationFeatures;
@@ -4144,7 +4144,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::smoothLines:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -4157,7 +4157,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->smoothLines, "VkPhysicalDeviceVulkan14Features::smoothLines"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceLineRasterizationFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceLineRasterizationFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceLineRasterizationFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceLineRasterizationFeatures;
@@ -4172,7 +4172,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::stippledBresenhamLines:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -4185,7 +4185,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->stippledBresenhamLines, "VkPhysicalDeviceVulkan14Features::stippledBresenhamLines"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceLineRasterizationFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceLineRasterizationFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceLineRasterizationFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceLineRasterizationFeatures;
@@ -4200,7 +4200,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::stippledRectangularLines:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -4213,7 +4213,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->stippledRectangularLines, "VkPhysicalDeviceVulkan14Features::stippledRectangularLines"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceLineRasterizationFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceLineRasterizationFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceLineRasterizationFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceLineRasterizationFeatures;
@@ -4229,7 +4229,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::stippledSmoothLines:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -4242,7 +4242,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->stippledSmoothLines, "VkPhysicalDeviceVulkan14Features::stippledSmoothLines"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceLineRasterizationFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceLineRasterizationFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceLineRasterizationFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceLineRasterizationFeatures;
@@ -4256,7 +4256,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->stippledSmoothLines, "VkPhysicalDeviceLineRasterizationFeatures::stippledSmoothLines"};
             }
         case Feature::linearColorAttachment: {
-            auto vk_struct = const_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceLinearColorAttachmentFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceLinearColorAttachmentFeaturesNV;
@@ -4271,7 +4271,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::maintenance10: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMaintenance10FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMaintenance10FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMaintenance10FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMaintenance10FeaturesKHR;
@@ -4286,7 +4286,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::maintenance11: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMaintenance11FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMaintenance11FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMaintenance11FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMaintenance11FeaturesKHR;
@@ -4302,7 +4302,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::maintenance4:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -4315,7 +4315,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->maintenance4, "VkPhysicalDeviceVulkan13Features::maintenance4"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceMaintenance4Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceMaintenance4Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceMaintenance4Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceMaintenance4Features;
@@ -4330,7 +4330,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::maintenance5:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -4343,7 +4343,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->maintenance5, "VkPhysicalDeviceVulkan14Features::maintenance5"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceMaintenance5Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceMaintenance5Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceMaintenance5Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceMaintenance5Features;
@@ -4358,7 +4358,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::maintenance6:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -4371,7 +4371,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->maintenance6, "VkPhysicalDeviceVulkan14Features::maintenance6"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceMaintenance6Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceMaintenance6Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceMaintenance6Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceMaintenance6Features;
@@ -4385,7 +4385,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->maintenance6, "VkPhysicalDeviceMaintenance6Features::maintenance6"};
             }
         case Feature::maintenance7: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMaintenance7FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMaintenance7FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMaintenance7FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMaintenance7FeaturesKHR;
@@ -4400,7 +4400,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::maintenance8: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMaintenance8FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMaintenance8FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMaintenance8FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMaintenance8FeaturesKHR;
@@ -4415,7 +4415,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::maintenance9: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMaintenance9FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMaintenance9FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMaintenance9FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMaintenance9FeaturesKHR;
@@ -4430,7 +4430,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::memoryMapPlaced: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMapMemoryPlacedFeaturesEXT;
@@ -4445,7 +4445,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::memoryMapRangePlaced: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMapMemoryPlacedFeaturesEXT;
@@ -4460,7 +4460,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::memoryUnmapReserve: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMapMemoryPlacedFeaturesEXT;
@@ -4475,7 +4475,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::memoryDecompression: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMemoryDecompressionFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMemoryDecompressionFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMemoryDecompressionFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMemoryDecompressionFeaturesEXT;
@@ -4490,7 +4490,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::memoryPriority: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMemoryPriorityFeaturesEXT;
@@ -4505,7 +4505,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::meshShaderQueries: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMeshShaderFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMeshShaderFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMeshShaderFeaturesEXT;
@@ -4520,7 +4520,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::multiviewMeshShader: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMeshShaderFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMeshShaderFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMeshShaderFeaturesEXT;
@@ -4535,7 +4535,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::primitiveFragmentShadingRateMeshShader: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMeshShaderFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMeshShaderFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMeshShaderFeaturesEXT;
@@ -4551,7 +4551,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::meshShader: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMeshShaderFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMeshShaderFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMeshShaderFeaturesEXT;
@@ -4566,7 +4566,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::taskShader: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMeshShaderFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMeshShaderFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMeshShaderFeaturesEXT;
@@ -4581,7 +4581,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::multiDraw: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMultiDrawFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMultiDrawFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMultiDrawFeaturesEXT;
@@ -4596,7 +4596,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::multisampledRenderToSingleSampled: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
@@ -4612,7 +4612,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::multisampledRenderToSwapchain: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT;
@@ -4629,7 +4629,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::multiview:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan11Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan11Features;
@@ -4642,7 +4642,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->multiview, "VkPhysicalDeviceVulkan11Features::multiview"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceMultiviewFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceMultiviewFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceMultiviewFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceMultiviewFeatures;
@@ -4657,7 +4657,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::multiviewGeometryShader:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan11Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan11Features;
@@ -4670,7 +4670,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->multiviewGeometryShader, "VkPhysicalDeviceVulkan11Features::multiviewGeometryShader"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceMultiviewFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceMultiviewFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceMultiviewFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceMultiviewFeatures;
@@ -4685,7 +4685,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::multiviewTessellationShader:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan11Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan11Features;
@@ -4698,7 +4698,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->multiviewTessellationShader, "VkPhysicalDeviceVulkan11Features::multiviewTessellationShader"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceMultiviewFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceMultiviewFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceMultiviewFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceMultiviewFeatures;
@@ -4712,7 +4712,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->multiviewTessellationShader, "VkPhysicalDeviceMultiviewFeatures::multiviewTessellationShader"};
             }
         case Feature::multiviewPerViewRenderAreas: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
@@ -4728,7 +4728,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::multiviewPerViewViewports: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
@@ -4744,7 +4744,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::mutableDescriptorType: {
-            auto vk_struct = const_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT;
@@ -4759,7 +4759,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::nestedCommandBuffer: {
-            auto vk_struct = const_cast<VkPhysicalDeviceNestedCommandBufferFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceNestedCommandBufferFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceNestedCommandBufferFeaturesEXT;
@@ -4774,7 +4774,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::nestedCommandBufferRendering: {
-            auto vk_struct = const_cast<VkPhysicalDeviceNestedCommandBufferFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceNestedCommandBufferFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceNestedCommandBufferFeaturesEXT;
@@ -4790,7 +4790,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::nestedCommandBufferSimultaneousUse: {
-            auto vk_struct = const_cast<VkPhysicalDeviceNestedCommandBufferFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceNestedCommandBufferFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceNestedCommandBufferFeaturesEXT;
@@ -4806,7 +4806,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::nonSeamlessCubeMap: {
-            auto vk_struct = const_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
@@ -4821,7 +4821,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::micromap: {
-            auto vk_struct = const_cast<VkPhysicalDeviceOpacityMicromapFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceOpacityMicromapFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceOpacityMicromapFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceOpacityMicromapFeaturesKHR;
@@ -4836,7 +4836,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::opticalFlow: {
-            auto vk_struct = const_cast<VkPhysicalDeviceOpticalFlowFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceOpticalFlowFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceOpticalFlowFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceOpticalFlowFeaturesNV;
@@ -4851,7 +4851,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::pageableDeviceLocalMemory: {
-            auto vk_struct = const_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
@@ -4867,7 +4867,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::partitionedAccelerationStructure: {
-            auto vk_struct = const_cast<VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV;
@@ -4883,7 +4883,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::dynamicPipelineLayout: {
-            auto vk_struct = const_cast<VkPhysicalDevicePerStageDescriptorSetFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePerStageDescriptorSetFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePerStageDescriptorSetFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePerStageDescriptorSetFeaturesNV;
@@ -4898,7 +4898,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::perStageDescriptorSet: {
-            auto vk_struct = const_cast<VkPhysicalDevicePerStageDescriptorSetFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePerStageDescriptorSetFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePerStageDescriptorSetFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePerStageDescriptorSetFeaturesNV;
@@ -4913,7 +4913,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::performanceCountersByRegion: {
-            auto vk_struct = const_cast<VkPhysicalDevicePerformanceCountersByRegionFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePerformanceCountersByRegionFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePerformanceCountersByRegionFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePerformanceCountersByRegionFeaturesARM;
@@ -4929,7 +4929,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::performanceCounterMultipleQueryPools: {
-            auto vk_struct = const_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePerformanceQueryFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePerformanceQueryFeaturesKHR;
@@ -4945,7 +4945,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::performanceCounterQueryPools: {
-            auto vk_struct = const_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePerformanceQueryFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePerformanceQueryFeaturesKHR;
@@ -4961,7 +4961,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::pipelineBinaries: {
-            auto vk_struct = const_cast<VkPhysicalDevicePipelineBinaryFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePipelineBinaryFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePipelineBinaryFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePipelineBinaryFeaturesKHR;
@@ -4976,7 +4976,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::pipelineCacheIncrementalMode: {
-            auto vk_struct = const_cast<VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC;
@@ -4993,7 +4993,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::pipelineCreationCacheControl:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -5006,7 +5006,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->pipelineCreationCacheControl, "VkPhysicalDeviceVulkan13Features::pipelineCreationCacheControl"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDevicePipelineCreationCacheControlFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDevicePipelineCreationCacheControlFeatures;
@@ -5021,7 +5021,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDevicePipelineCreationCacheControlFeatures::pipelineCreationCacheControl"};
             }
         case Feature::pipelineExecutableInfo: {
-            auto vk_struct = const_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
@@ -5037,7 +5037,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::pipelineLibraryGroupHandles: {
-            auto vk_struct = const_cast<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
@@ -5053,7 +5053,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::pipelineOpacityMicromap: {
-            auto vk_struct = const_cast<VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePipelineOpacityMicromapFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePipelineOpacityMicromapFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePipelineOpacityMicromapFeaturesARM;
@@ -5069,7 +5069,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::pipelinePropertiesIdentifier: {
-            auto vk_struct = const_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePipelinePropertiesFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePipelinePropertiesFeaturesEXT;
@@ -5086,7 +5086,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::pipelineProtectedAccess:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -5099,7 +5099,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->pipelineProtectedAccess, "VkPhysicalDeviceVulkan14Features::pipelineProtectedAccess"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDevicePipelineProtectedAccessFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDevicePipelineProtectedAccessFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDevicePipelineProtectedAccessFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDevicePipelineProtectedAccessFeatures;
@@ -5115,7 +5115,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::pipelineRobustness:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -5128,7 +5128,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->pipelineRobustness, "VkPhysicalDeviceVulkan14Features::pipelineRobustness"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDevicePipelineRobustnessFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDevicePipelineRobustnessFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDevicePipelineRobustnessFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDevicePipelineRobustnessFeatures;
@@ -5143,26 +5143,26 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
-                case Feature::constantAlphaColorBlendFactors : {
-                auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
-                    vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
-                if (!vk_struct) {
-                    vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
-                    *vk_struct = vku::InitStructHelper();
-                    if (*inout_pnext_chain) {
-                        vvl::PnextChainAdd(*inout_pnext_chain, vk_struct);
-                    } else {
-                        *inout_pnext_chain = vk_struct;
-                    }
+            case Feature::constantAlphaColorBlendFactors: {
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
+                vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
+            if (!vk_struct) {
+                vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
+                *vk_struct = vku::InitStructHelper();
+                if (*inout_pnext_chain) {
+                    vvl::PnextChainAdd(*inout_pnext_chain, vk_struct);
+                } else {
+                    *inout_pnext_chain = vk_struct;
                 }
-                return {&vk_struct->constantAlphaColorBlendFactors,
-                        "VkPhysicalDevicePortabilitySubsetFeaturesKHR::constantAlphaColorBlendFactors"};
             }
+            return {&vk_struct->constantAlphaColorBlendFactors,
+                    "VkPhysicalDevicePortabilitySubsetFeaturesKHR::constantAlphaColorBlendFactors"};
+        }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::events: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5179,7 +5179,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::imageView2DOn3DImage: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5196,7 +5196,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::imageViewFormatReinterpretation: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5214,7 +5214,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::imageViewFormatSwizzle: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5231,7 +5231,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::multisampleArrayImage: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5248,7 +5248,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::mutableComparisonSamplers: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5266,7 +5266,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::pointPolygons: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5283,7 +5283,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::samplerMipLodBias: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5300,7 +5300,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::separateStencilMaskRef: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5317,7 +5317,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::shaderSampleRateInterpolationFunctions: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5335,7 +5335,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::tessellationIsolines: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5352,7 +5352,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::tessellationPointMode: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5369,7 +5369,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::triangleFans: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5386,7 +5386,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::vertexAttributeAccessBeyondStride: {
-            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePortabilitySubsetFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePortabilitySubsetFeaturesKHR;
@@ -5403,7 +5403,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::presentBarrier: {
-            auto vk_struct = const_cast<VkPhysicalDevicePresentBarrierFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePresentBarrierFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePresentBarrierFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePresentBarrierFeaturesNV;
@@ -5418,7 +5418,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::presentId2: {
-            auto vk_struct = const_cast<VkPhysicalDevicePresentId2FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePresentId2FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePresentId2FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePresentId2FeaturesKHR;
@@ -5433,7 +5433,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::presentId: {
-            auto vk_struct = const_cast<VkPhysicalDevicePresentIdFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePresentIdFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePresentIdFeaturesKHR;
@@ -5448,7 +5448,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::presentMetering: {
-            auto vk_struct = const_cast<VkPhysicalDevicePresentMeteringFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePresentMeteringFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePresentMeteringFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePresentMeteringFeaturesNV;
@@ -5463,7 +5463,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::presentModeFifoLatestReady: {
-            auto vk_struct = const_cast<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR;
@@ -5479,7 +5479,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::presentAtAbsoluteTime: {
-            auto vk_struct = const_cast<VkPhysicalDevicePresentTimingFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePresentTimingFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePresentTimingFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePresentTimingFeaturesEXT;
@@ -5494,7 +5494,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::presentAtRelativeTime: {
-            auto vk_struct = const_cast<VkPhysicalDevicePresentTimingFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePresentTimingFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePresentTimingFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePresentTimingFeaturesEXT;
@@ -5509,7 +5509,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::presentTiming: {
-            auto vk_struct = const_cast<VkPhysicalDevicePresentTimingFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePresentTimingFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePresentTimingFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePresentTimingFeaturesEXT;
@@ -5524,7 +5524,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::presentWait2: {
-            auto vk_struct = const_cast<VkPhysicalDevicePresentWait2FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePresentWait2FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePresentWait2FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePresentWait2FeaturesKHR;
@@ -5539,7 +5539,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::presentWait: {
-            auto vk_struct = const_cast<VkPhysicalDevicePresentWaitFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePresentWaitFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePresentWaitFeaturesKHR;
@@ -5554,7 +5554,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::primitiveRestartIndex: {
-            auto vk_struct = const_cast<VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT;
@@ -5569,7 +5569,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::primitiveTopologyListRestart: {
-            auto vk_struct = const_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
@@ -5585,7 +5585,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::primitiveTopologyPatchListRestart: {
-            auto vk_struct = const_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
@@ -5601,7 +5601,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::primitivesGeneratedQuery: {
-            auto vk_struct = const_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
@@ -5617,7 +5617,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::primitivesGeneratedQueryWithNonZeroStreams: {
-            auto vk_struct = const_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
@@ -5633,7 +5633,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::primitivesGeneratedQueryWithRasterizerDiscard: {
-            auto vk_struct = const_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
@@ -5650,7 +5650,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::privateData:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -5663,7 +5663,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->privateData, "VkPhysicalDeviceVulkan13Features::privateData"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDevicePrivateDataFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDevicePrivateDataFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDevicePrivateDataFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDevicePrivateDataFeatures;
@@ -5678,7 +5678,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::protectedMemory:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan11Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan11Features;
@@ -5691,7 +5691,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->protectedMemory, "VkPhysicalDeviceVulkan11Features::protectedMemory"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceProtectedMemoryFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceProtectedMemoryFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceProtectedMemoryFeatures;
@@ -5705,7 +5705,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->protectedMemory, "VkPhysicalDeviceProtectedMemoryFeatures::protectedMemory"};
             }
         case Feature::provokingVertexLast: {
-            auto vk_struct = const_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceProvokingVertexFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceProvokingVertexFeaturesEXT;
@@ -5720,7 +5720,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::transformFeedbackPreservesProvokingVertex: {
-            auto vk_struct = const_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceProvokingVertexFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceProvokingVertexFeaturesEXT;
@@ -5736,7 +5736,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::pushConstantBank: {
-            auto vk_struct = const_cast<VkPhysicalDevicePushConstantBankFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDevicePushConstantBankFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDevicePushConstantBankFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDevicePushConstantBankFeaturesNV;
@@ -5751,7 +5751,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::queuePerfHint: {
-            auto vk_struct = const_cast<VkPhysicalDeviceQueuePerfHintFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceQueuePerfHintFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceQueuePerfHintFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceQueuePerfHintFeaturesQCOM;
@@ -5766,7 +5766,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::formatRgba10x6WithoutYCbCrSampler: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT;
@@ -5782,7 +5782,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rasterizationOrderColorAttachmentAccess: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
@@ -5798,7 +5798,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rasterizationOrderDepthAttachmentAccess: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
@@ -5814,7 +5814,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rasterizationOrderStencilAttachmentAccess: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
@@ -5830,7 +5830,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderRawAccessChains: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRawAccessChainsFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRawAccessChainsFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRawAccessChainsFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRawAccessChainsFeaturesNV;
@@ -5845,7 +5845,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rayQuery: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayQueryFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayQueryFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayQueryFeaturesKHR;
@@ -5860,7 +5860,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rayTracingInvocationReorder: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT;
@@ -5876,7 +5876,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::linearSweptSpheres: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV;
@@ -5891,7 +5891,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::spheres: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV;
@@ -5906,7 +5906,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rayTracingMaintenance1: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR;
@@ -5922,7 +5922,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rayTracingPipelineTraceRaysIndirect2: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR;
@@ -5938,7 +5938,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rayTracingMotionBlur: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingMotionBlurFeaturesNV;
@@ -5953,7 +5953,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rayTracingMotionBlurPipelineTraceRaysIndirect: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingMotionBlurFeaturesNV;
@@ -5969,7 +5969,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rayTracingPipeline: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingPipelineFeaturesKHR;
@@ -5984,7 +5984,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rayTracingPipelineShaderGroupHandleCaptureReplay: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingPipelineFeaturesKHR;
@@ -6000,7 +6000,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rayTracingPipelineShaderGroupHandleCaptureReplayMixed: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingPipelineFeaturesKHR;
@@ -6016,7 +6016,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rayTracingPipelineTraceRaysIndirect: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingPipelineFeaturesKHR;
@@ -6032,7 +6032,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rayTraversalPrimitiveCulling: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingPipelineFeaturesKHR;
@@ -6048,7 +6048,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rayTracingPositionFetch: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR;
@@ -6064,7 +6064,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::rayTracingValidation: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingValidationFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRayTracingValidationFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingValidationFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRayTracingValidationFeaturesNV;
@@ -6079,7 +6079,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::relaxedLineRasterization: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG;
@@ -6095,7 +6095,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::renderPassStriped: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRenderPassStripedFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRenderPassStripedFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRenderPassStripedFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRenderPassStripedFeaturesARM;
@@ -6110,7 +6110,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::representativeFragmentTest: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;
@@ -6126,7 +6126,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::nullDescriptor: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRobustness2FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRobustness2FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRobustness2FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRobustness2FeaturesKHR;
@@ -6141,7 +6141,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::robustBufferAccess2: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRobustness2FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRobustness2FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRobustness2FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRobustness2FeaturesKHR;
@@ -6156,7 +6156,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::robustImageAccess2: {
-            auto vk_struct = const_cast<VkPhysicalDeviceRobustness2FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceRobustness2FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceRobustness2FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceRobustness2FeaturesKHR;
@@ -6172,7 +6172,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::samplerYcbcrConversion:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan11Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan11Features;
@@ -6185,7 +6185,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->samplerYcbcrConversion, "VkPhysicalDeviceVulkan11Features::samplerYcbcrConversion"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceSamplerYcbcrConversionFeatures;
@@ -6201,7 +6201,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::scalarBlockLayout:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -6214,7 +6214,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->scalarBlockLayout, "VkPhysicalDeviceVulkan12Features::scalarBlockLayout"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceScalarBlockLayoutFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceScalarBlockLayoutFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceScalarBlockLayoutFeatures;
@@ -6228,7 +6228,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->scalarBlockLayout, "VkPhysicalDeviceScalarBlockLayoutFeatures::scalarBlockLayout"};
             }
         case Feature::schedulingControls: {
-            auto vk_struct = const_cast<VkPhysicalDeviceSchedulingControlsFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceSchedulingControlsFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceSchedulingControlsFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceSchedulingControlsFeaturesARM;
@@ -6244,7 +6244,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::separateDepthStencilLayouts:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -6257,7 +6257,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->separateDepthStencilLayouts, "VkPhysicalDeviceVulkan12Features::separateDepthStencilLayouts"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;
@@ -6272,7 +6272,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::separateDepthStencilLayouts"};
             }
         case Feature::shader64BitIndexing: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShader64BitIndexingFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShader64BitIndexingFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShader64BitIndexingFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShader64BitIndexingFeaturesEXT;
@@ -6287,7 +6287,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderAbort: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAbortFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAbortFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAbortFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAbortFeaturesKHR;
@@ -6302,7 +6302,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderFloat16VectorAtomics: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
@@ -6318,7 +6318,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderBufferFloat16AtomicAdd: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -6334,7 +6334,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderBufferFloat16AtomicMinMax: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -6350,7 +6350,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderBufferFloat16Atomics: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -6366,7 +6366,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderBufferFloat32AtomicMinMax: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -6382,7 +6382,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderBufferFloat64AtomicMinMax: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -6398,7 +6398,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderImageFloat32AtomicMinMax: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -6414,7 +6414,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderSharedFloat16AtomicAdd: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -6430,7 +6430,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderSharedFloat16AtomicMinMax: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -6446,7 +6446,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderSharedFloat16Atomics: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -6462,7 +6462,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderSharedFloat32AtomicMinMax: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -6478,7 +6478,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderSharedFloat64AtomicMinMax: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -6494,7 +6494,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::sparseImageFloat32AtomicMinMax: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@@ -6510,7 +6510,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderBufferFloat32AtomicAdd: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -6526,7 +6526,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderBufferFloat32Atomics: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -6542,7 +6542,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderBufferFloat64AtomicAdd: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -6558,7 +6558,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderBufferFloat64Atomics: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -6574,7 +6574,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderImageFloat32AtomicAdd: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -6590,7 +6590,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderImageFloat32Atomics: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -6606,7 +6606,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderSharedFloat32AtomicAdd: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -6622,7 +6622,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderSharedFloat32Atomics: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -6638,7 +6638,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderSharedFloat64AtomicAdd: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -6654,7 +6654,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderSharedFloat64Atomics: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -6670,7 +6670,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::sparseImageFloat32AtomicAdd: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -6686,7 +6686,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::sparseImageFloat32Atomics: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;
@@ -6703,7 +6703,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::shaderBufferInt64Atomics:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -6716,7 +6716,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->shaderBufferInt64Atomics, "VkPhysicalDeviceVulkan12Features::shaderBufferInt64Atomics"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicInt64Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicInt64Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceShaderAtomicInt64Features;
@@ -6732,7 +6732,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderSharedInt64Atomics:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -6745,7 +6745,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->shaderSharedInt64Atomics, "VkPhysicalDeviceVulkan12Features::shaderSharedInt64Atomics"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicInt64Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceShaderAtomicInt64Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceShaderAtomicInt64Features;
@@ -6760,7 +6760,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDeviceShaderAtomicInt64Features::shaderSharedInt64Atomics"};
             }
         case Feature::shaderBFloat16CooperativeMatrix: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderBfloat16FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderBfloat16FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderBfloat16FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderBfloat16FeaturesKHR;
@@ -6776,7 +6776,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderBFloat16DotProduct: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderBfloat16FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderBfloat16FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderBfloat16FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderBfloat16FeaturesKHR;
@@ -6791,7 +6791,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderBFloat16Type: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderBfloat16FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderBfloat16FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderBfloat16FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderBfloat16FeaturesKHR;
@@ -6806,7 +6806,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderDeviceClock: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderClockFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderClockFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderClockFeaturesKHR;
@@ -6821,7 +6821,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderSubgroupClock: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderClockFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderClockFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderClockFeaturesKHR;
@@ -6836,7 +6836,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderConstantData: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderConstantDataFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderConstantDataFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderConstantDataFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderConstantDataFeaturesKHR;
@@ -6851,7 +6851,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderCoreBuiltins: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM;
@@ -6867,7 +6867,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::shaderDemoteToHelperInvocation:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -6881,7 +6881,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderDemoteToHelperInvocation,
                         "VkPhysicalDeviceVulkan13Features::shaderDemoteToHelperInvocation"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures;
@@ -6897,7 +6897,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderDrawParameters:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan11Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan11Features;
@@ -6910,7 +6910,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->shaderDrawParameters, "VkPhysicalDeviceVulkan11Features::shaderDrawParameters"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceShaderDrawParametersFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceShaderDrawParametersFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceShaderDrawParametersFeatures;
@@ -6924,7 +6924,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderDrawParameters, "VkPhysicalDeviceShaderDrawParametersFeatures::shaderDrawParameters"};
             }
         case Feature::shaderEarlyAndLateFragmentTests: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
@@ -6941,7 +6941,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::shaderEnqueue: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderEnqueueFeaturesAMDX *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderEnqueueFeaturesAMDX*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderEnqueueFeaturesAMDX>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderEnqueueFeaturesAMDX;
@@ -6958,7 +6958,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
         case Feature::shaderMeshEnqueue: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderEnqueueFeaturesAMDX *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderEnqueueFeaturesAMDX*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderEnqueueFeaturesAMDX>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderEnqueueFeaturesAMDX;
@@ -6975,7 +6975,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::shaderExpectAssume:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -6988,7 +6988,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->shaderExpectAssume, "VkPhysicalDeviceVulkan14Features::shaderExpectAssume"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceShaderExpectAssumeFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceShaderExpectAssumeFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceShaderExpectAssumeFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceShaderExpectAssumeFeatures;
@@ -7003,7 +7003,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderFloat16:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -7016,7 +7016,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->shaderFloat16, "VkPhysicalDeviceVulkan12Features::shaderFloat16"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceShaderFloat16Int8Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceShaderFloat16Int8Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceShaderFloat16Int8Features;
@@ -7031,7 +7031,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderInt8:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -7044,7 +7044,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->shaderInt8, "VkPhysicalDeviceVulkan12Features::shaderInt8"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceShaderFloat16Int8Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceShaderFloat16Int8Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceShaderFloat16Int8Features;
@@ -7058,7 +7058,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderInt8, "VkPhysicalDeviceShaderFloat16Int8Features::shaderInt8"};
             }
         case Feature::shaderFloat8: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderFloat8FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderFloat8FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderFloat8FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderFloat8FeaturesEXT;
@@ -7073,7 +7073,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderFloat8CooperativeMatrix: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderFloat8FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderFloat8FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderFloat8FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderFloat8FeaturesEXT;
@@ -7090,7 +7090,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::shaderFloatControls2:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -7103,7 +7103,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->shaderFloatControls2, "VkPhysicalDeviceVulkan14Features::shaderFloatControls2"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceShaderFloatControls2Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceShaderFloatControls2Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceShaderFloatControls2Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceShaderFloatControls2Features;
@@ -7117,7 +7117,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderFloatControls2, "VkPhysicalDeviceShaderFloatControls2Features::shaderFloatControls2"};
             }
         case Feature::shaderFmaFloat16: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderFmaFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderFmaFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderFmaFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderFmaFeaturesKHR;
@@ -7132,7 +7132,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderFmaFloat32: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderFmaFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderFmaFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderFmaFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderFmaFeaturesKHR;
@@ -7147,7 +7147,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderFmaFloat64: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderFmaFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderFmaFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderFmaFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderFmaFeaturesKHR;
@@ -7162,7 +7162,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderImageInt64Atomics: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
@@ -7178,7 +7178,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::sparseImageInt64Atomics: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
@@ -7194,7 +7194,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::imageFootprint: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderImageFootprintFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderImageFootprintFeaturesNV;
@@ -7209,7 +7209,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderInstrumentation: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderInstrumentationFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderInstrumentationFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderInstrumentationFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderInstrumentationFeaturesARM;
@@ -7225,7 +7225,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::shaderIntegerDotProduct:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -7238,7 +7238,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->shaderIntegerDotProduct, "VkPhysicalDeviceVulkan13Features::shaderIntegerDotProduct"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceShaderIntegerDotProductFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceShaderIntegerDotProductFeatures;
@@ -7253,7 +7253,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDeviceShaderIntegerDotProductFeatures::shaderIntegerDotProduct"};
             }
         case Feature::shaderIntegerFunctions2: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
@@ -7269,7 +7269,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::longVector: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderLongVectorFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderLongVectorFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderLongVectorFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderLongVectorFeaturesEXT;
@@ -7284,7 +7284,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderMaximalReconvergence: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
@@ -7300,7 +7300,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderMixedFloatDotProductBFloat16Acc: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE;
@@ -7316,7 +7316,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderMixedFloatDotProductFloat16AccFloat16: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE;
@@ -7332,7 +7332,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderMixedFloatDotProductFloat16AccFloat32: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE;
@@ -7348,7 +7348,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderMixedFloatDotProductFloat8AccFloat32: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE;
@@ -7364,7 +7364,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderModuleIdentifier: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT;
@@ -7380,7 +7380,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderMultipleWaitQueues: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM;
@@ -7396,7 +7396,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderFloat4: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT;
@@ -7411,7 +7411,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderFloat6: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT;
@@ -7426,7 +7426,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderFloat8UnsignedE8M0: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT;
@@ -7442,7 +7442,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderMXInt8: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT;
@@ -7457,7 +7457,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderObject: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderObjectFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderObjectFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderObjectFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderObjectFeaturesEXT;
@@ -7472,7 +7472,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderQuadControl: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderQuadControlFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderQuadControlFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderQuadControlFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderQuadControlFeaturesKHR;
@@ -7487,7 +7487,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderRelaxedExtendedInstruction: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;
@@ -7503,7 +7503,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderReplicatedComposites: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT;
@@ -7519,7 +7519,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderSMBuiltins: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;
@@ -7534,7 +7534,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderSplitBarrier: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderSplitBarrierFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderSplitBarrierFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderSplitBarrierFeaturesEXT;
@@ -7550,7 +7550,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::shaderSubgroupExtendedTypes:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -7563,7 +7563,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->shaderSubgroupExtendedTypes, "VkPhysicalDeviceVulkan12Features::shaderSubgroupExtendedTypes"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;
@@ -7578,7 +7578,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::shaderSubgroupExtendedTypes"};
             }
         case Feature::shaderSubgroupPartitioned: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT;
@@ -7595,7 +7595,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::shaderSubgroupRotate:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -7608,7 +7608,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->shaderSubgroupRotate, "VkPhysicalDeviceVulkan14Features::shaderSubgroupRotate"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceShaderSubgroupRotateFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceShaderSubgroupRotateFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceShaderSubgroupRotateFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceShaderSubgroupRotateFeatures;
@@ -7623,7 +7623,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderSubgroupRotateClustered:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -7637,7 +7637,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderSubgroupRotateClustered,
                         "VkPhysicalDeviceVulkan14Features::shaderSubgroupRotateClustered"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceShaderSubgroupRotateFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceShaderSubgroupRotateFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceShaderSubgroupRotateFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceShaderSubgroupRotateFeatures;
@@ -7652,7 +7652,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDeviceShaderSubgroupRotateFeatures::shaderSubgroupRotateClustered"};
             }
         case Feature::shaderSubgroupUniformControlFlow: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
@@ -7669,7 +7669,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::shaderTerminateInvocation:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -7682,7 +7682,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->shaderTerminateInvocation, "VkPhysicalDeviceVulkan13Features::shaderTerminateInvocation"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceShaderTerminateInvocationFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceShaderTerminateInvocationFeatures;
@@ -7697,7 +7697,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDeviceShaderTerminateInvocationFeatures::shaderTerminateInvocation"};
             }
         case Feature::shaderTileImageColorReadAccess: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderTileImageFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderTileImageFeaturesEXT;
@@ -7713,7 +7713,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderTileImageDepthReadAccess: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderTileImageFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderTileImageFeaturesEXT;
@@ -7729,7 +7729,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderTileImageStencilReadAccess: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderTileImageFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderTileImageFeaturesEXT;
@@ -7745,7 +7745,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderUniformBufferUnsizedArray: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT;
@@ -7761,7 +7761,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderUntypedPointers: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShaderUntypedPointersFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShaderUntypedPointersFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShaderUntypedPointersFeaturesKHR;
@@ -7776,7 +7776,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shadingRateCoarseSampleOrder: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShadingRateImageFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShadingRateImageFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShadingRateImageFeaturesNV;
@@ -7792,7 +7792,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shadingRateImage: {
-            auto vk_struct = const_cast<VkPhysicalDeviceShadingRateImageFeaturesNV *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceShadingRateImageFeaturesNV>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceShadingRateImageFeaturesNV;
@@ -7808,7 +7808,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::computeFullSubgroups:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -7821,7 +7821,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->computeFullSubgroups, "VkPhysicalDeviceVulkan13Features::computeFullSubgroups"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceSubgroupSizeControlFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceSubgroupSizeControlFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceSubgroupSizeControlFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceSubgroupSizeControlFeatures;
@@ -7836,7 +7836,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::subgroupSizeControl:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -7849,7 +7849,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->subgroupSizeControl, "VkPhysicalDeviceVulkan13Features::subgroupSizeControl"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceSubgroupSizeControlFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceSubgroupSizeControlFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceSubgroupSizeControlFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceSubgroupSizeControlFeatures;
@@ -7863,7 +7863,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->subgroupSizeControl, "VkPhysicalDeviceSubgroupSizeControlFeatures::subgroupSizeControl"};
             }
         case Feature::subpassMergeFeedback: {
-            auto vk_struct = const_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT;
@@ -7878,7 +7878,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::subpassShading: {
-            auto vk_struct = const_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceSubpassShadingFeaturesHUAWEI;
@@ -7893,7 +7893,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::swapchainMaintenance1: {
-            auto vk_struct = const_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR;
@@ -7909,7 +7909,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::synchronization2:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -7922,7 +7922,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->synchronization2, "VkPhysicalDeviceVulkan13Features::synchronization2"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceSynchronization2Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceSynchronization2Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceSynchronization2Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceSynchronization2Features;
@@ -7936,7 +7936,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->synchronization2, "VkPhysicalDeviceSynchronization2Features::synchronization2"};
             }
         case Feature::descriptorBindingStorageTensorUpdateAfterBind: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTensorFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTensorFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTensorFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTensorFeaturesARM;
@@ -7952,7 +7952,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderStorageTensorArrayDynamicIndexing: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTensorFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTensorFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTensorFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTensorFeaturesARM;
@@ -7968,7 +7968,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderStorageTensorArrayNonUniformIndexing: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTensorFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTensorFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTensorFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTensorFeaturesARM;
@@ -7984,7 +7984,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderTensorAccess: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTensorFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTensorFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTensorFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTensorFeaturesARM;
@@ -7999,7 +7999,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tensorNonPacked: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTensorFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTensorFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTensorFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTensorFeaturesARM;
@@ -8014,7 +8014,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tensors: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTensorFeaturesARM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTensorFeaturesARM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTensorFeaturesARM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTensorFeaturesARM;
@@ -8029,7 +8029,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::texelBufferAlignment: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;
@@ -8044,7 +8044,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::textureCompressionASTC_3D: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT;
@@ -8061,7 +8061,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::textureCompressionASTC_HDR:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -8074,7 +8074,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->textureCompressionASTC_HDR, "VkPhysicalDeviceVulkan13Features::textureCompressionASTC_HDR"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceTextureCompressionASTCHDRFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceTextureCompressionASTCHDRFeatures;
@@ -8089,7 +8089,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDeviceTextureCompressionASTCHDRFeatures::textureCompressionASTC_HDR"};
             }
         case Feature::throttleHint: {
-            auto vk_struct = const_cast<VkPhysicalDeviceThrottleHintFeaturesSEC *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceThrottleHintFeaturesSEC*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceThrottleHintFeaturesSEC>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceThrottleHintFeaturesSEC;
@@ -8104,7 +8104,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileMemoryHeap: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileMemoryHeapFeaturesQCOM;
@@ -8119,7 +8119,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileProperties: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTilePropertiesFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTilePropertiesFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTilePropertiesFeaturesQCOM;
@@ -8134,7 +8134,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShading: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8149,7 +8149,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShadingAnisotropicApron: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8165,7 +8165,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShadingApron: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8180,7 +8180,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShadingAtomicOps: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8195,7 +8195,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShadingColorAttachments: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8211,7 +8211,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShadingDepthAttachments: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8227,7 +8227,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShadingDispatchTile: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8242,7 +8242,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShadingFragmentStage: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8257,7 +8257,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShadingImageProcessing: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8272,7 +8272,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShadingInputAttachments: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8288,7 +8288,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShadingPerTileDispatch: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8303,7 +8303,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShadingPerTileDraw: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8318,7 +8318,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShadingSampledAttachments: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8334,7 +8334,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::tileShadingStencilAttachments: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTileShadingFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTileShadingFeaturesQCOM;
@@ -8351,7 +8351,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::timelineSemaphore:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -8364,7 +8364,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->timelineSemaphore, "VkPhysicalDeviceVulkan12Features::timelineSemaphore"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceTimelineSemaphoreFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceTimelineSemaphoreFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceTimelineSemaphoreFeatures;
@@ -8378,7 +8378,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->timelineSemaphore, "VkPhysicalDeviceTimelineSemaphoreFeatures::timelineSemaphore"};
             }
         case Feature::geometryStreams: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTransformFeedbackFeaturesEXT;
@@ -8393,7 +8393,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::transformFeedback: {
-            auto vk_struct = const_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceTransformFeedbackFeaturesEXT;
@@ -8408,7 +8408,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::unifiedImageLayouts: {
-            auto vk_struct = const_cast<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR;
@@ -8423,7 +8423,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::unifiedImageLayoutsVideo: {
-            auto vk_struct = const_cast<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR;
@@ -8440,7 +8440,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::uniformBufferStandardLayout:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -8453,7 +8453,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->uniformBufferStandardLayout, "VkPhysicalDeviceVulkan12Features::uniformBufferStandardLayout"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceUniformBufferStandardLayoutFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceUniformBufferStandardLayoutFeatures;
@@ -8469,7 +8469,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::variablePointers:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan11Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan11Features;
@@ -8482,7 +8482,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->variablePointers, "VkPhysicalDeviceVulkan11Features::variablePointers"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceVariablePointersFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVariablePointersFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVariablePointersFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVariablePointersFeatures;
@@ -8497,7 +8497,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::variablePointersStorageBuffer:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan11Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan11Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan11Features;
@@ -8511,7 +8511,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->variablePointersStorageBuffer,
                         "VkPhysicalDeviceVulkan11Features::variablePointersStorageBuffer"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceVariablePointersFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVariablePointersFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVariablePointersFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVariablePointersFeatures;
@@ -8527,7 +8527,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::vertexAttributeInstanceRateDivisor:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -8541,7 +8541,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->vertexAttributeInstanceRateDivisor,
                         "VkPhysicalDeviceVulkan14Features::vertexAttributeInstanceRateDivisor"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceVertexAttributeDivisorFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVertexAttributeDivisorFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVertexAttributeDivisorFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVertexAttributeDivisorFeatures;
@@ -8557,7 +8557,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::vertexAttributeInstanceRateZeroDivisor:
             if (api_version >= VK_API_VERSION_1_4) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -8571,7 +8571,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->vertexAttributeInstanceRateZeroDivisor,
                         "VkPhysicalDeviceVulkan14Features::vertexAttributeInstanceRateZeroDivisor"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceVertexAttributeDivisorFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVertexAttributeDivisorFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVertexAttributeDivisorFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVertexAttributeDivisorFeatures;
@@ -8586,7 +8586,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDeviceVertexAttributeDivisorFeatures::vertexAttributeInstanceRateZeroDivisor"};
             }
         case Feature::vertexAttributeRobustness: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
@@ -8602,7 +8602,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::vertexInputDynamicState: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT;
@@ -8618,7 +8618,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::videoDecodeVP9: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVideoDecodeVP9FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVideoDecodeVP9FeaturesKHR;
@@ -8633,7 +8633,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::videoEncodeAV1: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVideoEncodeAV1FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVideoEncodeAV1FeaturesKHR;
@@ -8648,7 +8648,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::videoEncodeFeedback2: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR;
@@ -8663,7 +8663,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::videoEncodeIntraRefresh: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR;
@@ -8679,7 +8679,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::videoEncodeQuantizationMap: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR;
@@ -8695,7 +8695,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::videoEncodeRgbConversion: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE;
@@ -8711,7 +8711,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::videoMaintenance1: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVideoMaintenance1FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVideoMaintenance1FeaturesKHR;
@@ -8726,7 +8726,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::videoMaintenance2: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVideoMaintenance2FeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVideoMaintenance2FeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVideoMaintenance2FeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVideoMaintenance2FeaturesKHR;
@@ -8741,7 +8741,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::descriptorIndexing: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -8756,7 +8756,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::drawIndirectCount: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -8771,7 +8771,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::samplerFilterMinmax: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -8786,7 +8786,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::samplerMirrorClampToEdge: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -8801,7 +8801,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderOutputLayer: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -8816,7 +8816,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderOutputViewportIndex: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -8831,7 +8831,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::subgroupBroadcastDynamicId: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -8847,7 +8847,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
 
         case Feature::vulkanMemoryModel:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -8860,7 +8860,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->vulkanMemoryModel, "VkPhysicalDeviceVulkan12Features::vulkanMemoryModel"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkanMemoryModelFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkanMemoryModelFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkanMemoryModelFeatures;
@@ -8875,7 +8875,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::vulkanMemoryModelAvailabilityVisibilityChains:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -8889,7 +8889,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->vulkanMemoryModelAvailabilityVisibilityChains,
                         "VkPhysicalDeviceVulkan12Features::vulkanMemoryModelAvailabilityVisibilityChains"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkanMemoryModelFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkanMemoryModelFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkanMemoryModelFeatures;
@@ -8905,7 +8905,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::vulkanMemoryModelDeviceScope:
             if (api_version >= VK_API_VERSION_1_2) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan12Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan12Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan12Features;
@@ -8918,7 +8918,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 }
                 return {&vk_struct->vulkanMemoryModelDeviceScope, "VkPhysicalDeviceVulkan12Features::vulkanMemoryModelDeviceScope"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkanMemoryModelFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkanMemoryModelFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkanMemoryModelFeatures;
@@ -8934,7 +8934,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
             }
         case Feature::shaderZeroInitializeWorkgroupMemory:
             if (api_version >= VK_API_VERSION_1_3) {
-                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceVulkan13Features*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceVulkan13Features>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceVulkan13Features;
@@ -8948,7 +8948,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                 return {&vk_struct->shaderZeroInitializeWorkgroupMemory,
                         "VkPhysicalDeviceVulkan13Features::shaderZeroInitializeWorkgroupMemory"};
             } else {
-                auto vk_struct = const_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *>(
+                auto vk_struct = const_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
                     vku::FindStructInPNextChain<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>(*inout_pnext_chain));
                 if (!vk_struct) {
                     vk_struct = new VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
@@ -8963,7 +8963,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
                         "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::shaderZeroInitializeWorkgroupMemory"};
             }
         case Feature::pushDescriptor: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVulkan14Features*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVulkan14Features>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVulkan14Features;
@@ -8978,7 +8978,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::shaderAtomicInstructions: {
-            auto vk_struct = const_cast<VkPhysicalDeviceVulkanSC10Features *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceVulkanSC10Features*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceVulkanSC10Features>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceVulkanSC10Features;
@@ -8993,7 +8993,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::workgroupMemoryExplicitLayout: {
-            auto vk_struct = const_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
@@ -9009,7 +9009,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::workgroupMemoryExplicitLayout16BitAccess: {
-            auto vk_struct = const_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
@@ -9025,7 +9025,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::workgroupMemoryExplicitLayout8BitAccess: {
-            auto vk_struct = const_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
@@ -9041,7 +9041,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::workgroupMemoryExplicitLayoutScalarBlockLayout: {
-            auto vk_struct = const_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
@@ -9057,7 +9057,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::ycbcr2plane444Formats: {
-            auto vk_struct = const_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
@@ -9072,7 +9072,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::ycbcrDegamma: {
-            auto vk_struct = const_cast<VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceYcbcrDegammaFeaturesQCOM>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceYcbcrDegammaFeaturesQCOM;
@@ -9087,7 +9087,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::ycbcrImageArrays: {
-            auto vk_struct = const_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceYcbcrImageArraysFeaturesEXT;
@@ -9102,7 +9102,7 @@ FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **i
         }
 
         case Feature::zeroInitializeDeviceMemory: {
-            auto vk_struct = const_cast<VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *>(
+            auto vk_struct = const_cast<VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT*>(
                 vku::FindStructInPNextChain<VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT>(*inout_pnext_chain));
             if (!vk_struct) {
                 vk_struct = new VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT;
diff --git a/layers/vulkansc/generated/feature_requirements_helper.h b/layers/vulkansc/generated/feature_requirements_helper.h
index 0c547db76..2072fbdf4 100644
--- a/layers/vulkansc/generated/feature_requirements_helper.h
+++ b/layers/vulkansc/generated/feature_requirements_helper.h
@@ -1155,13 +1155,13 @@ enum class Feature {
 };
 
 struct FeatureAndName {
-    VkBool32 *feature;
-    const char *name;
+    VkBool32* feature;
+    const char* name;
 };
 
 // Find or add the correct VkPhysicalDeviceFeature struct in `pnext_chain` based on `feature`,
 // a vkt::Feature enum value, and set feature to VK_TRUE
-FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void **inout_pnext_chain);
+FeatureAndName AddFeature(APIVersion api_version, vkt::Feature feature, void** inout_pnext_chain);
 
 }  // namespace vkt
 
diff --git a/layers/vulkansc/generated/pnext_chain_extraction.cpp b/layers/vulkansc/generated/pnext_chain_extraction.cpp
index add278a21..986fd7948 100644
--- a/layers/vulkansc/generated/pnext_chain_extraction.cpp
+++ b/layers/vulkansc/generated/pnext_chain_extraction.cpp
@@ -28,4244 +28,4244 @@
 
 namespace vvl {
 
-void *PnextChainAdd(void *chain, void *new_struct) {
+void* PnextChainAdd(void* chain, void* new_struct) {
     assert(chain);
     assert(new_struct);
-    void *chain_end = vku::FindLastStructInPNextChain(chain);
-    auto *vk_base_struct = static_cast<VkBaseOutStructure *>(chain_end);
+    void* chain_end = vku::FindLastStructInPNextChain(chain);
+    auto* vk_base_struct = static_cast<VkBaseOutStructure*>(chain_end);
     assert(!vk_base_struct->pNext);
-    vk_base_struct->pNext = static_cast<VkBaseOutStructure *>(new_struct);
+    vk_base_struct->pNext = static_cast<VkBaseOutStructure*>(new_struct);
     return new_struct;
 }
 
-void PnextChainRemoveLast(void *chain) {
+void PnextChainRemoveLast(void* chain) {
     if (!chain) {
         return;
     }
-    auto *current = static_cast<VkBaseOutStructure *>(chain);
-    auto *prev = current;
+    auto* current = static_cast<VkBaseOutStructure*>(chain);
+    auto* prev = current;
     while (current->pNext) {
         prev = current;
-        current = static_cast<VkBaseOutStructure *>(current->pNext);
+        current = static_cast<VkBaseOutStructure*>(current->pNext);
     }
     prev->pNext = nullptr;
 }
 
-void PnextChainFree(void *chain) {
+void PnextChainFree(void* chain) {
     if (!chain) {
         return;
     }
-    auto header = reinterpret_cast<VkBaseOutStructure *>(chain);
+    auto header = reinterpret_cast<VkBaseOutStructure*>(chain);
     switch (header->sType) {
         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkShaderModuleCreateInfo *>(header);
+            delete reinterpret_cast<const VkShaderModuleCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineLayoutCreateInfo *>(header);
+            delete reinterpret_cast<const VkPipelineLayoutCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMemoryDedicatedRequirements *>(header);
+            delete reinterpret_cast<const VkMemoryDedicatedRequirements*>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMemoryDedicatedAllocateInfo *>(header);
+            delete reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMemoryAllocateFlagsInfo *>(header);
+            delete reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo *>(header);
+            delete reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceGroupSubmitInfo *>(header);
+            delete reinterpret_cast<const VkDeviceGroupSubmitInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceGroupBindSparseInfo *>(header);
+            delete reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo *>(header);
+            delete reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo *>(header);
+            delete reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceGroupDeviceCreateInfo *>(header);
+            delete reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFeatures2 *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFeatures2*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageViewUsageCreateInfo *>(header);
+            delete reinterpret_cast<const VkImageViewUsageCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkProtectedSubmitInfo *>(header);
+            delete reinterpret_cast<const VkProtectedSubmitInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkBindImagePlaneMemoryInfo *>(header);
+            delete reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo *>(header);
+            delete reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExternalImageFormatProperties *>(header);
+            delete reinterpret_cast<const VkExternalImageFormatProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceIDProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceIDProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExternalMemoryImageCreateInfo *>(header);
+            delete reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExternalMemoryBufferCreateInfo *>(header);
+            delete reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportMemoryAllocateInfo *>(header);
+            delete reinterpret_cast<const VkExportMemoryAllocateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportFenceCreateInfo *>(header);
+            delete reinterpret_cast<const VkExportFenceCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportSemaphoreCreateInfo *>(header);
+            delete reinterpret_cast<const VkExportSemaphoreCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSubgroupProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSamplerYcbcrConversionInfo *>(header);
+            delete reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties *>(header);
+            delete reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo *>(header);
+            delete reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePointClippingProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo *>(header);
+            delete reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo *>(header);
+            delete reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassMultiviewCreateInfo *>(header);
+            delete reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMultiviewProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDriverProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVulkan11Features *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVulkan11Properties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVulkan12Features *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVulkan12Properties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageFormatListCreateInfo *>(header);
+            delete reinterpret_cast<const VkImageFormatListCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSemaphoreTypeCreateInfo *>(header);
+            delete reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkTimelineSemaphoreSubmitInfo *>(header);
+            delete reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo *>(header);
+            delete reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo *>(header);
+            delete reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo *>(header);
+            delete reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo *>(header);
+            delete reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport *>(header);
+            delete reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSamplerReductionModeCreateInfo *>(header);
+            delete reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve *>(header);
+            delete reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageStencilUsageCreateInfo *>(header);
+            delete reinterpret_cast<const VkImageStencilUsageCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassAttachmentBeginInfo *>(header);
+            delete reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkFramebufferAttachmentsCreateInfo *>(header);
+            delete reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAttachmentReferenceStencilLayout *>(header);
+            delete reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(header);
             break;
         case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAttachmentDescriptionStencilLayout *>(header);
+            delete reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVulkan13Features *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVulkan13Properties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVulkan13Properties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDevicePrivateDataCreateInfo *>(header);
+            delete reinterpret_cast<const VkDevicePrivateDataCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMemoryBarrier2 *>(header);
+            delete reinterpret_cast<const VkMemoryBarrier2*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSynchronization2Features *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkFormatProperties3 *>(header);
+            delete reinterpret_cast<const VkFormatProperties3*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance4Features *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo *>(header);
+            delete reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *>(header);
+            delete reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock *>(header);
+            delete reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock*>(header);
             break;
         case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo *>(header);
+            delete reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineRenderingCreateInfo *>(header);
+            delete reinterpret_cast<const VkPipelineRenderingCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo *>(header);
+            delete reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVulkan14Features *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVulkan14Features*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVulkan14Properties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVulkan14Properties*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfo *>(header);
+            delete reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkQueueFamilyGlobalPriorityProperties *>(header);
+            delete reinterpret_cast<const VkQueueFamilyGlobalPriorityProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance5Features *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance5Features*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance5Properties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance5Properties*>(header);
             break;
         case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkBufferUsageFlags2CreateInfo *>(header);
+            delete reinterpret_cast<const VkBufferUsageFlags2CreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance6Features *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance6Features*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance6Properties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance6Properties*>(header);
             break;
         case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkBindMemoryStatus *>(header);
+            delete reinterpret_cast<const VkBindMemoryStatus*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceHostImageCopyProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceHostImageCopyProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSubresourceHostMemcpySize *>(header);
+            delete reinterpret_cast<const VkSubresourceHostMemcpySize*>(header);
             break;
         case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkHostImageCopyDevicePerformanceQuery *>(header);
+            delete reinterpret_cast<const VkHostImageCopyDevicePerformanceQuery*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineCreateFlags2CreateInfo *>(header);
+            delete reinterpret_cast<const VkPipelineCreateFlags2CreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePushDescriptorProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePushDescriptorProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePipelineRobustnessProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePipelineRobustnessProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineRobustnessCreateInfo *>(header);
+            delete reinterpret_cast<const VkPipelineRobustnessCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceLineRasterizationProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceLineRasterizationProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfo *>(header);
+            delete reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorProperties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorProperties*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfo *>(header);
+            delete reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderingAttachmentLocationInfo *>(header);
+            delete reinterpret_cast<const VkRenderingAttachmentLocationInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderingInputAttachmentIndexInfo *>(header);
+            delete reinterpret_cast<const VkRenderingInputAttachmentIndexInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVulkanSC10Features *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVulkanSC10Features*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVulkanSC10Properties *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVulkanSC10Properties*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceObjectReservationCreateInfo *>(header);
+            delete reinterpret_cast<const VkDeviceObjectReservationCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkCommandPoolMemoryReservationCreateInfo *>(header);
+            delete reinterpret_cast<const VkCommandPoolMemoryReservationCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkFaultCallbackInfo *>(header);
+            delete reinterpret_cast<const VkFaultCallbackInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineOfflineCreateInfo *>(header);
+            delete reinterpret_cast<const VkPipelineOfflineCreateInfo*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageSwapchainCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR *>(header);
+            delete reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceGroupPresentInfoKHR *>(header);
+            delete reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDisplayPresentInfoKHR *>(header);
+            delete reinterpret_cast<const VkDisplayPresentInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkQueueFamilyQueryResultStatusPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkQueueFamilyQueryResultStatusPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkQueueFamilyVideoPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkQueueFamilyVideoPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoProfileInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoProfileInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoProfileListInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoProfileListInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeCapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeCapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeUsageInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeUsageInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264CapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264CapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264QualityLevelPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264QualityLevelPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264SessionParametersGetInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264SessionParametersGetInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264SessionParametersFeedbackInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264SessionParametersFeedbackInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264PictureInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264PictureInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264ProfileInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264ProfileInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264RateControlInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264RateControlInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264GopRemainingFrameInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264GopRemainingFrameInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265CapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265CapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265QualityLevelPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265QualityLevelPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265SessionParametersGetInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265SessionParametersGetInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265SessionParametersFeedbackInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265SessionParametersFeedbackInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265PictureInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265PictureInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265ProfileInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265ProfileInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265RateControlInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265RateControlInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265GopRemainingFrameInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265GopRemainingFrameInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH264ProfileInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH264ProfileInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH264CapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH264CapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH264PictureInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH264PictureInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR*>(header);
             break;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR *>(header);
+            delete reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR *>(header);
+            delete reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(header);
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportMemoryFdInfoKHR *>(header);
+            delete reinterpret_cast<const VkImportMemoryFdInfoKHR*>(header);
             break;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR *>(header);
+            delete reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR *>(header);
+            delete reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkD3D12FenceSubmitInfoKHR *>(header);
+            delete reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(header);
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPresentRegionsKHR *>(header);
+            delete reinterpret_cast<const VkPresentRegionsKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(header);
             break;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportFenceWin32HandleInfoKHR *>(header);
+            delete reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(header);
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR *>(header);
+            delete reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPerformanceQueryReservationInfoKHR *>(header);
+            delete reinterpret_cast<const VkPerformanceQueryReservationInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR*>(header);
             break;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(header);
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH265ProfileInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH265ProfileInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH265CapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH265CapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH265PictureInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH265PictureInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR *>(header);
+            delete reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR *>(header);
+            delete reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderConstantDataFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderConstantDataFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderAbortFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderAbortFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceFaultShaderAbortMessageInfoKHR *>(header);
+            delete reinterpret_cast<const VkDeviceFaultShaderAbortMessageInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderAbortPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderAbortPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineLibraryCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPresentIdKHR *>(header);
+            delete reinterpret_cast<const VkPresentIdKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeUsageInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeUsageInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeRateControlInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeQualityLevelInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeQualityLevelInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMemoryRangeBarriersInfoKHR *>(header);
+            delete reinterpret_cast<const VkMemoryRangeBarriersInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSurfaceCapabilitiesPresentId2KHR *>(header);
+            delete reinterpret_cast<const VkSurfaceCapabilitiesPresentId2KHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPresentId2KHR *>(header);
+            delete reinterpret_cast<const VkPresentId2KHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePresentId2FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePresentId2FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSurfaceCapabilitiesPresentWait2KHR *>(header);
+            delete reinterpret_cast<const VkSurfaceCapabilitiesPresentWait2KHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePresentWait2FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePresentWait2FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePipelineBinaryPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePipelineBinaryPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDevicePipelineBinaryInternalCacheControlKHR *>(header);
+            delete reinterpret_cast<const VkDevicePipelineBinaryInternalCacheControlKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineBinaryInfoKHR *>(header);
+            delete reinterpret_cast<const VkPipelineBinaryInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSurfacePresentModeKHR *>(header);
+            delete reinterpret_cast<const VkSurfacePresentModeKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSurfacePresentScalingCapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkSurfacePresentScalingCapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSurfacePresentModeCompatibilityKHR *>(header);
+            delete reinterpret_cast<const VkSurfacePresentModeCompatibilityKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSwapchainPresentFenceInfoKHR *>(header);
+            delete reinterpret_cast<const VkSwapchainPresentFenceInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSwapchainPresentModesCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkSwapchainPresentModesCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSwapchainPresentModeInfoKHR *>(header);
+            delete reinterpret_cast<const VkSwapchainPresentModeInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSwapchainPresentScalingCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkSwapchainPresentScalingCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeAV1ProfileInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeAV1ProfileInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeAV1CapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeAV1CapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeAV1SessionParametersCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeAV1SessionParametersCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeAV1PictureInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeAV1PictureInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeAV1DpbSlotInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeAV1DpbSlotInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeAV1CapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeAV1CapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeAV1QualityLevelPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeAV1QualityLevelPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeAV1SessionCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeAV1SessionCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeAV1SessionParametersCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeAV1SessionParametersCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeAV1PictureInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeAV1PictureInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeAV1DpbSlotInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeAV1DpbSlotInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeAV1ProfileInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeAV1ProfileInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeAV1GopRemainingFrameInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeAV1GopRemainingFrameInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeAV1RateControlInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeAV1RateControlInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeAV1RateControlLayerInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeAV1RateControlLayerInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeVP9ProfileInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeVP9ProfileInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeVP9CapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeVP9CapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeVP9PictureInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeVP9PictureInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoInlineQueryInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoInlineQueryInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAttachmentFeedbackLoopInfoEXT *>(header);
+            delete reinterpret_cast<const VkAttachmentFeedbackLoopInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeIntraRefreshCapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeIntraRefreshCapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeSessionIntraRefreshCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeSessionIntraRefreshCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeIntraRefreshInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeIntraRefreshInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoReferenceIntraRefreshInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoReferenceIntraRefreshInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeQuantizationMapCapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeQuantizationMapCapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoFormatQuantizationMapPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoFormatQuantizationMapPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeQuantizationMapInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeQuantizationMapInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH264QuantizationMapCapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeH265QuantizationMapCapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoFormatH265QuantizationMapPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoFormatH265QuantizationMapPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoFormatAV1QuantizationMapPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoFormatAV1QuantizationMapPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance7FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance7FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance7PropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance7PropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceLayeredApiPropertiesListKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceLayeredApiPropertiesListKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFaultFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFaultFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFaultPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFaultPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMemoryBarrierAccessFlags3KHR *>(header);
+            delete reinterpret_cast<const VkMemoryBarrierAccessFlags3KHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance8FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance8FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance9FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance9FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance9PropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance9PropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkQueueFamilyOwnershipTransferPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkQueueFamilyOwnershipTransferPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH264InlineSessionParametersInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH264InlineSessionParametersInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeH265InlineSessionParametersInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeH265InlineSessionParametersInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoDecodeAV1InlineSessionParametersInfoKHR *>(header);
+            delete reinterpret_cast<const VkVideoDecodeAV1InlineSessionParametersInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_FEEDBACK_2_CAPABILITIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeFeedback2CapabilitiesKHR *>(header);
+            delete reinterpret_cast<const VkVideoEncodeFeedback2CapabilitiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAccelerationStructureGeometryMicromapDataKHR *>(header);
+            delete reinterpret_cast<const VkAccelerationStructureGeometryMicromapDataKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapKHR *>(header);
+            delete reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance10FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance10FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance10PropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance10PropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderingAttachmentFlagsInfoKHR *>(header);
+            delete reinterpret_cast<const VkRenderingAttachmentFlagsInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkResolveImageModeInfoKHR *>(header);
+            delete reinterpret_cast<const VkResolveImageModeInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMaintenance11FeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMaintenance11FeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR *>(header);
+            delete reinterpret_cast<const VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkFormatProperties4KHR *>(header);
+            delete reinterpret_cast<const VkFormatProperties4KHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageUsageFlags2CreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkImageUsageFlags2CreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageCreateFlags2CreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkImageCreateFlags2CreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageViewUsage2CreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkImageViewUsage2CreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExtendedFlagsFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExtendedFlagsFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageStencilUsage2CreateInfoKHR *>(header);
+            delete reinterpret_cast<const VkImageStencilUsage2CreateInfoKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSharedPresentSurfaceCapabilities2KHR *>(header);
+            delete reinterpret_cast<const VkSharedPresentSurfaceCapabilities2KHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD *>(header);
+            delete reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV *>(header);
+            delete reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkCuModuleTexturingModeCreateInfoNVX *>(header);
+            delete reinterpret_cast<const VkCuModuleTexturingModeCreateInfoNVX*>(header);
             break;
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD *>(header);
+            delete reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExternalMemoryImageCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportMemoryAllocateInfoNV *>(header);
+            delete reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(header);
             break;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportMemoryWin32HandleInfoNV *>(header);
+            delete reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportMemoryWin32HandleInfoNV *>(header);
+            delete reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV *>(header);
+            delete reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(header);
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkValidationFlagsEXT *>(header);
+            delete reinterpret_cast<const VkValidationFlagsEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageViewASTCDecodeModeEXT *>(header);
+            delete reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(header);
+            delete reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSwapchainCounterCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPresentTimesInfoGOOGLE *>(header);
+            delete reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(header);
             break;
         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX *>(header);
+            delete reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>(header);
+            delete reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(header);
             break;
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID *>(header);
+            delete reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(header);
             break;
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID *>(header);
+            delete reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID *>(header);
+            delete reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExternalFormatANDROID *>(header);
+            delete reinterpret_cast<const VkExternalFormatANDROID*>(header);
             break;
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID *>(header);
+            delete reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(header);
             break;
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceGpaFeaturesAMD *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceGpaFeaturesAMD*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceGpaPropertiesAMD *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceGpaPropertiesAMD*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceGpaProperties2AMD *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceGpaProperties2AMD*>(header);
             break;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>(header);
+            delete reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX*>(header);
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkShaderDescriptorSetAndBindingMappingInfoEXT *>(header);
+            delete reinterpret_cast<const VkShaderDescriptorSetAndBindingMappingInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkOpaqueCaptureDataCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkOpaqueCaptureDataCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDescriptorHeapFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDescriptorHeapFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDescriptorHeapPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDescriptorHeapPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkCommandBufferInheritanceDescriptorHeapInfoEXT *>(header);
+            delete reinterpret_cast<const VkCommandBufferInheritanceDescriptorHeapInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSamplerCustomBorderColorIndexCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkSamplerCustomBorderColorIndexCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkIndirectCommandsLayoutPushDataTokenNV *>(header);
+            delete reinterpret_cast<const VkIndirectCommandsLayoutPushDataTokenNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSubsampledImageFormatPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkSubsampledImageFormatPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAttachmentSampleCountInfoAMD *>(header);
+            delete reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSampleLocationsInfoEXT *>(header);
+            delete reinterpret_cast<const VkSampleLocationsInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT *>(header);
+            delete reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT *>(header);
+            delete reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT *>(header);
+            delete reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV *>(header);
+            delete reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportMemoryHostPointerInfoEXT *>(header);
+            delete reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD *>(header);
+            delete reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD *>(header);
+            delete reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(header);
             break;
 #ifdef VK_USE_PLATFORM_GGP
         case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPresentFrameTokenGGP *>(header);
+            delete reinterpret_cast<const VkPresentFrameTokenGGP*>(header);
             break;
 #endif  // VK_USE_PLATFORM_GGP
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV *>(header);
+            delete reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV *>(header);
+            delete reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePresentTimingFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePresentTimingFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPresentTimingSurfaceCapabilitiesEXT *>(header);
+            delete reinterpret_cast<const VkPresentTimingSurfaceCapabilitiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSwapchainCalibratedTimestampInfoEXT *>(header);
+            delete reinterpret_cast<const VkSwapchainCalibratedTimestampInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPresentTimingsInfoEXT *>(header);
+            delete reinterpret_cast<const VkPresentTimingsInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(header);
             break;
         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL *>(header);
+            delete reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(header);
+            delete reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD *>(header);
+            delete reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT *>(header);
+            delete reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT *>(header);
+            delete reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkValidationFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkValidationFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(header);
             break;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT *>(header);
+            delete reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(header);
+            delete reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT *>(header);
+            delete reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(header);
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMemoryMapPlacedInfoEXT *>(header);
+            delete reinterpret_cast<const VkMemoryMapPlacedInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV *>(header);
+            delete reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM *>(header);
+            delete reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>(header);
+            delete reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDepthBiasRepresentationInfoEXT *>(header);
+            delete reinterpret_cast<const VkDepthBiasRepresentationInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSurfaceCapabilitiesPresentBarrierNV *>(header);
+            delete reinterpret_cast<const VkSurfaceCapabilitiesPresentBarrierNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSwapchainPresentBarrierCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkSwapchainPresentBarrierCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceQueuePerfHintFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceQueuePerfHintFeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceQueuePerfHintPropertiesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceQueuePerfHintPropertiesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageProcessing3FeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageProcessing3FeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderSplitBarrierPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderSplitBarrierPropertiesEXT*>(header);
             break;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchPropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchPropertiesNV*>(header);
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTileShadingPropertiesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTileShadingPropertiesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassTileShadingCreateInfoQCOM *>(header);
+            delete reinterpret_cast<const VkRenderPassTileShadingCreateInfoQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkQueryLowLatencySupportNV *>(header);
+            delete reinterpret_cast<const VkQueryLowLatencySupportNV*>(header);
             break;
 #ifdef VK_USE_PLATFORM_METAL_EXT
         case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportMetalObjectCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkExportMetalObjectCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportMetalDeviceInfoEXT *>(header);
+            delete reinterpret_cast<const VkExportMetalDeviceInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportMetalCommandQueueInfoEXT *>(header);
+            delete reinterpret_cast<const VkExportMetalCommandQueueInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportMetalBufferInfoEXT *>(header);
+            delete reinterpret_cast<const VkExportMetalBufferInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportMetalBufferInfoEXT *>(header);
+            delete reinterpret_cast<const VkImportMetalBufferInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportMetalTextureInfoEXT *>(header);
+            delete reinterpret_cast<const VkExportMetalTextureInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportMetalTextureInfoEXT *>(header);
+            delete reinterpret_cast<const VkImportMetalTextureInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportMetalIOSurfaceInfoEXT *>(header);
+            delete reinterpret_cast<const VkExportMetalIOSurfaceInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportMetalIOSurfaceInfoEXT *>(header);
+            delete reinterpret_cast<const VkImportMetalIOSurfaceInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportMetalSharedEventInfoEXT *>(header);
+            delete reinterpret_cast<const VkExportMetalSharedEventInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportMetalSharedEventInfoEXT *>(header);
+            delete reinterpret_cast<const VkImportMetalSharedEventInfoEXT*>(header);
             break;
 #endif  // VK_USE_PLATFORM_METAL_EXT
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *>(header);
+            delete reinterpret_cast<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkOpaqueCaptureDescriptorDataCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkGraphicsPipelineLibraryCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkGraphicsPipelineLibraryCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV *>(header);
+            delete reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAccelerationStructureMotionInfoNV *>(header);
+            delete reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkCopyCommandTransformInfoQCOM *>(header);
+            delete reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageCompressionControlEXT *>(header);
+            delete reinterpret_cast<const VkImageCompressionControlEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageCompressionPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkImageCompressionPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMutableDescriptorTypeCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkMutableDescriptorTypeCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceAddressBindingCallbackDataEXT *>(header);
+            delete reinterpret_cast<const VkDeviceAddressBindingCallbackDataEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(header);
             break;
 #ifdef VK_USE_PLATFORM_FUCHSIA
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA *>(header);
+            delete reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA *>(header);
+            delete reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(header);
             break;
         case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA *>(header);
+            delete reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(header);
             break;
         case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA *>(header);
+            delete reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(header);
             break;
 #endif  // VK_USE_PLATFORM_FUCHSIA
         case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI *>(header);
+            delete reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(header);
             break;
 #ifdef VK_USE_PLATFORM_SCI
         case VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportFenceSciSyncInfoNV *>(header);
+            delete reinterpret_cast<const VkExportFenceSciSyncInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_SCI_SYNC_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportSemaphoreSciSyncInfoNV *>(header);
+            delete reinterpret_cast<const VkExportSemaphoreSciSyncInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExternalSciSyncFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExternalSciSyncFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_SCI_BUF_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExportMemorySciBufInfoNV *>(header);
+            delete reinterpret_cast<const VkExportMemorySciBufInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_SCI_BUF_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportMemorySciBufInfoNV *>(header);
+            delete reinterpret_cast<const VkImportMemorySciBufInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExternalMemorySciBufFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExternalMemorySciBufFeaturesNV*>(header);
             break;
 #endif  // VK_USE_PLATFORM_SCI
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkFrameBoundaryEXT *>(header);
+            delete reinterpret_cast<const VkFrameBoundaryEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSubpassResolvePerformanceQueryEXT *>(header);
+            delete reinterpret_cast<const VkSubpassResolvePerformanceQueryEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMultisampledRenderToSingleSampledInfoEXT *>(header);
+            delete reinterpret_cast<const VkMultisampledRenderToSingleSampledInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeRgbConversionCapabilitiesVALVE *>(header);
+            delete reinterpret_cast<const VkVideoEncodeRgbConversionCapabilitiesVALVE*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeProfileRgbConversionInfoVALVE *>(header);
+            delete reinterpret_cast<const VkVideoEncodeProfileRgbConversionInfoVALVE*>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkVideoEncodeSessionRgbConversionCreateInfoVALVE *>(header);
+            delete reinterpret_cast<const VkVideoEncodeSessionRgbConversionCreateInfoVALVE*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageViewMinLodCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkImageViewMinLodCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderTileImagePropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderTileImagePropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapEXT *>(header);
+            delete reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapEXT*>(header);
             break;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapPropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAccelerationStructureTrianglesDisplacementMicromapNV *>(header);
+            delete reinterpret_cast<const VkAccelerationStructureTrianglesDisplacementMicromapNV*>(header);
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceQueueShaderCoreControlCreateInfoARM *>(header);
+            delete reinterpret_cast<const VkDeviceQueueShaderCoreControlCreateInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSchedulingControlsPropertiesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSchedulingControlsPropertiesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_PROPERTIES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageViewSlicedCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkImageViewSlicedCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRenderPassStripedPropertiesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRenderPassStripedPropertiesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassStripeBeginInfoARM *>(header);
+            delete reinterpret_cast<const VkRenderPassStripeBeginInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassStripeSubmitInfoARM *>(header);
+            delete reinterpret_cast<const VkRenderPassStripeSubmitInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassFragmentDensityMapOffsetEndInfoEXT *>(header);
+            delete reinterpret_cast<const VkRenderPassFragmentDensityMapOffsetEndInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkComputePipelineIndirectBufferInfoNV *>(header);
+            delete reinterpret_cast<const VkComputePipelineIndirectBufferInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAccelerationStructureGeometryLinearSweptSpheresDataNV *>(header);
+            delete reinterpret_cast<const VkAccelerationStructureGeometryLinearSweptSpheresDataNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAccelerationStructureGeometrySpheresDataNV *>(header);
+            delete reinterpret_cast<const VkAccelerationStructureGeometrySpheresDataNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkApplicationParametersEXT *>(header);
+            delete reinterpret_cast<const VkApplicationParametersEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageViewSampleWeightCreateInfoQCOM *>(header);
+            delete reinterpret_cast<const VkImageViewSampleWeightCreateInfoQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageProcessingPropertiesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageProcessingPropertiesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferPropertiesEXT*>(header);
             break;
 #ifdef VK_USE_PLATFORM_OHOS
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkNativeBufferUsageOHOS *>(header);
+            delete reinterpret_cast<const VkNativeBufferUsageOHOS*>(header);
             break;
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkNativeBufferFormatPropertiesOHOS *>(header);
+            delete reinterpret_cast<const VkNativeBufferFormatPropertiesOHOS*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportNativeBufferInfoOHOS *>(header);
+            delete reinterpret_cast<const VkImportNativeBufferInfoOHOS*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExternalFormatOHOS *>(header);
+            delete reinterpret_cast<const VkExternalFormatOHOS*>(header);
             break;
 #endif  // VK_USE_PLATFORM_OHOS
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExternalMemoryAcquireUnmodifiedEXT *>(header);
+            delete reinterpret_cast<const VkExternalMemoryAcquireUnmodifiedEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassCreationControlEXT *>(header);
+            delete reinterpret_cast<const VkRenderPassCreationControlEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassCreationFeedbackCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkRenderPassCreationFeedbackCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassSubpassFeedbackCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkRenderPassSubpassFeedbackCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDirectDriverLoadingListLUNARG *>(header);
+            delete reinterpret_cast<const VkDirectDriverLoadingListLUNARG*>(header);
             break;
         case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkTensorDescriptionARM *>(header);
+            delete reinterpret_cast<const VkTensorDescriptionARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkWriteDescriptorSetTensorARM *>(header);
+            delete reinterpret_cast<const VkWriteDescriptorSetTensorARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkTensorFormatPropertiesARM *>(header);
+            delete reinterpret_cast<const VkTensorFormatPropertiesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTensorPropertiesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTensorPropertiesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkTensorMemoryBarrierARM *>(header);
+            delete reinterpret_cast<const VkTensorMemoryBarrierARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkTensorDependencyInfoARM *>(header);
+            delete reinterpret_cast<const VkTensorDependencyInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTensorFeaturesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTensorFeaturesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMemoryDedicatedAllocateInfoTensorARM *>(header);
+            delete reinterpret_cast<const VkMemoryDedicatedAllocateInfoTensorARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExternalMemoryTensorCreateInfoARM *>(header);
+            delete reinterpret_cast<const VkExternalMemoryTensorCreateInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDescriptorGetTensorInfoARM *>(header);
+            delete reinterpret_cast<const VkDescriptorGetTensorInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkFrameBoundaryTensorsARM *>(header);
+            delete reinterpret_cast<const VkFrameBoundaryTensorsARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceOpticalFlowPropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceOpticalFlowPropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>(header);
+            delete reinterpret_cast<const VkOpticalFlowImageFormatInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkOpticalFlowSessionCreatePrivateDataInfoNV *>(header);
+            delete reinterpret_cast<const VkOpticalFlowSessionCreatePrivateDataInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(header);
             break;
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID*>(header);
             break;
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAndroidHardwareBufferFormatResolvePropertiesANDROID *>(header);
+            delete reinterpret_cast<const VkAndroidHardwareBufferFormatResolvePropertiesANDROID*>(header);
             break;
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD*>(header);
             break;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX*>(header);
             break;
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX *>(header);
+            delete reinterpret_cast<const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX*>(header);
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderObjectPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderObjectPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(header);
             break;
         case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkAmigoProfilingSubmitInfoSEC *>(header);
+            delete reinterpret_cast<const VkAmigoProfilingSubmitInfoSEC*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(header);
             break;
 #ifdef VK_USE_PLATFORM_SCI
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExternalSciSync2FeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExternalSciSync2FeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSemaphoreSciSyncCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkSemaphoreSciSyncCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV*>(header);
             break;
 #endif  // VK_USE_PLATFORM_SCI
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCooperativeVectorPropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCooperativeVectorPropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkLayerSettingsCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkLayerSettingsCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkLatencySubmissionPresentIdNV *>(header);
+            delete reinterpret_cast<const VkLatencySubmissionPresentIdNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSwapchainLatencyCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkSwapchainLatencyCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkLatencySurfaceCapabilitiesNV *>(header);
+            delete reinterpret_cast<const VkLatencySurfaceCapabilitiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDataGraphFeaturesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDataGraphFeaturesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDataGraphPipelineCompilerControlCreateInfoARM *>(header);
+            delete reinterpret_cast<const VkDataGraphPipelineCompilerControlCreateInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDataGraphPipelineShaderModuleCreateInfoARM *>(header);
+            delete reinterpret_cast<const VkDataGraphPipelineShaderModuleCreateInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDataGraphPipelineIdentifierCreateInfoARM *>(header);
+            delete reinterpret_cast<const VkDataGraphPipelineIdentifierCreateInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDataGraphProcessingEngineCreateInfoARM *>(header);
+            delete reinterpret_cast<const VkDataGraphProcessingEngineCreateInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *>(header);
+            delete reinterpret_cast<const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *>(header);
+            delete reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageProcessing2PropertiesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageProcessing2PropertiesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSamplerBlockMatchWindowCreateInfoQCOM *>(header);
+            delete reinterpret_cast<const VkSamplerBlockMatchWindowCreateInfoQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSamplerCubicWeightsCreateInfoQCOM *>(header);
+            delete reinterpret_cast<const VkSamplerCubicWeightsCreateInfoQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkBlitImageCubicWeightsInfoQCOM *>(header);
+            delete reinterpret_cast<const VkBlitImageCubicWeightsInfoQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM *>(header);
+            delete reinterpret_cast<const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCubicClampFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCubicClampFeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(header);
             break;
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
         case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkScreenBufferFormatPropertiesQNX *>(header);
+            delete reinterpret_cast<const VkScreenBufferFormatPropertiesQNX*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportScreenBufferInfoQNX *>(header);
+            delete reinterpret_cast<const VkImportScreenBufferInfoQNX*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExternalFormatQNX *>(header);
+            delete reinterpret_cast<const VkExternalFormatQNX*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*>(header);
             break;
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceLayeredDriverPropertiesMSFT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceLayeredDriverPropertiesMSFT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkTileMemoryRequirementsQCOM *>(header);
+            delete reinterpret_cast<const VkTileMemoryRequirementsQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkTileMemoryBindInfoQCOM *>(header);
+            delete reinterpret_cast<const VkTileMemoryBindInfoQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkTileMemorySizeInfoQCOM *>(header);
+            delete reinterpret_cast<const VkTileMemorySizeInfoQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDisplaySurfaceStereoCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkDisplaySurfaceStereoCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDisplayModeStereoPropertiesNV *>(header);
+            delete reinterpret_cast<const VkDisplayModeStereoPropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkExternalComputeQueueDeviceCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkExternalComputeQueueDeviceCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceExternalComputeQueuePropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceExternalComputeQueuePropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_TENSOR_ROLLING_BACKING_CREATE_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkTensorRollingBackingCreateInfoARM *>(header);
+            delete reinterpret_cast<const VkTensorRollingBackingCreateInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_TENSOR_EXPLICIT_TILING_FORMAT_PROPERTIES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkTensorExplicitTilingFormatPropertiesARM *>(header);
+            delete reinterpret_cast<const VkTensorExplicitTilingFormatPropertiesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderFloat8FeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderFloat8FeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV *>(header);
+            delete reinterpret_cast<const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPartitionedAccelerationStructureFlagsNV *>(header);
+            delete reinterpret_cast<const VkPartitionedAccelerationStructureFlagsNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkWriteDescriptorSetPartitionedAccelerationStructureNV *>(header);
+            delete reinterpret_cast<const VkWriteDescriptorSetPartitionedAccelerationStructureNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkGeneratedCommandsPipelineInfoEXT *>(header);
+            delete reinterpret_cast<const VkGeneratedCommandsPipelineInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkGeneratedCommandsShaderInfoEXT *>(header);
+            delete reinterpret_cast<const VkGeneratedCommandsShaderInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlPropertiesMESA *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlPropertiesMESA*>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImageAlignmentControlCreateInfoMESA *>(header);
+            delete reinterpret_cast<const VkImageAlignmentControlCreateInfoMESA*>(header);
             break;
         case VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPushConstantBankInfoNV *>(header);
+            delete reinterpret_cast<const VkPushConstantBankInfoNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePushConstantBankFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePushConstantBankFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePushConstantBankPropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePushConstantBankPropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDepthClampControlFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDepthClampControlFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineViewportDepthClampControlCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkPipelineViewportDepthClampControlCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceHdrVividFeaturesHUAWEI *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceHdrVividFeaturesHUAWEI*>(header);
             break;
         case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkHdrVividDynamicMetadataHUAWEI *>(header);
+            delete reinterpret_cast<const VkHdrVividDynamicMetadataHUAWEI*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2PropertiesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM*>(header);
             break;
 #ifdef VK_USE_PLATFORM_METAL_EXT
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkImportMemoryMetalHandleInfoEXT *>(header);
+            delete reinterpret_cast<const VkImportMemoryMetalHandleInfoEXT*>(header);
             break;
 #endif  // VK_USE_PLATFORM_METAL_EXT
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionPropertiesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionPropertiesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkRenderPassPerformanceCountersByRegionBeginInfoARM *>(header);
+            delete reinterpret_cast<const VkRenderPassPerformanceCountersByRegionBeginInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationFeaturesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationFeaturesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationPropertiesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationPropertiesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFormatPackFeaturesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFormatPackFeaturesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE*>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *>(header);
+            delete reinterpret_cast<const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE*>(header);
             break;
         case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSetPresentConfigNV *>(header);
+            delete reinterpret_cast<const VkSetPresentConfigNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_FLAGS_SURFACE_CAPABILITIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkSwapchainFlagsSurfaceCapabilitiesEXT *>(header);
+            delete reinterpret_cast<const VkSwapchainFlagsSurfaceCapabilitiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShader64BitIndexingFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShader64BitIndexingFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCustomResolveFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCustomResolveFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkCustomResolveCreateInfoEXT *>(header);
+            delete reinterpret_cast<const VkCustomResolveCreateInfoEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>(header);
+            delete reinterpret_cast<const VkDataGraphPipelineBuiltinModelCreateInfoQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDataGraphPipelineOpticalFlowCreateInfoARM *>(header);
+            delete reinterpret_cast<const VkDataGraphPipelineOpticalFlowCreateInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDataGraphOpticalFlowImageFormatInfoARM *>(header);
+            delete reinterpret_cast<const VkDataGraphOpticalFlowImageFormatInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDataGraphPipelineOpticalFlowDispatchInfoARM *>(header);
+            delete reinterpret_cast<const VkDataGraphPipelineOpticalFlowDispatchInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDataGraphPipelineResourceInfoImageLayoutARM *>(header);
+            delete reinterpret_cast<const VkDataGraphPipelineResourceInfoImageLayoutARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDataGraphPipelineSingleNodeCreateInfoARM *>(header);
+            delete reinterpret_cast<const VkDataGraphPipelineSingleNodeCreateInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderLongVectorFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderLongVectorFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderLongVectorPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderLongVectorPropertiesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OCP_MICROSCALING_TYPES_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE*>(header);
             break;
         case VK_STRUCTURE_TYPE_THROTTLE_HINT_SUBMIT_INFO_SEC:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkThrottleHintSubmitInfoSEC *>(header);
+            delete reinterpret_cast<const VkThrottleHintSubmitInfoSEC*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceThrottleHintFeaturesSEC *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceThrottleHintFeaturesSEC*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDataGraphPipelineNeuralStatisticsCreateInfoARM *>(header);
+            delete reinterpret_cast<const VkDataGraphPipelineNeuralStatisticsCreateInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM *>(header);
+            delete reinterpret_cast<const VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV*>(header);
             break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(header);
+            delete reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
             PnextChainFree(header->pNext);
             header->pNext = nullptr;
-            delete reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesEXT *>(header);
+            delete reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesEXT*>(header);
             break;
         default:
             assert(false);
@@ -4274,12 +4274,12 @@ void PnextChainFree(void *chain) {
 }
 
 template <>
-void *PnextChainExtract(const void *in_pnext_chain, PnextChainVkPhysicalDeviceImageFormatInfo2 &out) {
-    void *chain_begin = nullptr;
-    void *chain_end = nullptr;
+void* PnextChainExtract(const void* in_pnext_chain, PnextChainVkPhysicalDeviceImageFormatInfo2& out) {
+    void* chain_begin = nullptr;
+    void* chain_end = nullptr;
 
-    if (auto *chain_struct = vku::FindStructInPNextChain<VkDataGraphOpticalFlowImageFormatInfoARM>(in_pnext_chain)) {
-        auto &out_chain_struct = std::get<VkDataGraphOpticalFlowImageFormatInfoARM>(out);
+    if (auto* chain_struct = vku::FindStructInPNextChain<VkDataGraphOpticalFlowImageFormatInfoARM>(in_pnext_chain)) {
+        auto& out_chain_struct = std::get<VkDataGraphOpticalFlowImageFormatInfoARM>(out);
         out_chain_struct = *chain_struct;
         out_chain_struct.pNext = nullptr;
         if (!chain_begin) {
@@ -4290,8 +4290,8 @@ void *PnextChainExtract(const void *in_pnext_chain, PnextChainVkPhysicalDeviceIm
         }
     }
 
-    if (auto *chain_struct = vku::FindStructInPNextChain<VkImageCompressionControlEXT>(in_pnext_chain)) {
-        auto &out_chain_struct = std::get<VkImageCompressionControlEXT>(out);
+    if (auto* chain_struct = vku::FindStructInPNextChain<VkImageCompressionControlEXT>(in_pnext_chain)) {
+        auto& out_chain_struct = std::get<VkImageCompressionControlEXT>(out);
         out_chain_struct = *chain_struct;
         out_chain_struct.pNext = nullptr;
         if (!chain_begin) {
@@ -4302,8 +4302,8 @@ void *PnextChainExtract(const void *in_pnext_chain, PnextChainVkPhysicalDeviceIm
         }
     }
 
-    if (auto *chain_struct = vku::FindStructInPNextChain<VkImageCreateFlags2CreateInfoKHR>(in_pnext_chain)) {
-        auto &out_chain_struct = std::get<VkImageCreateFlags2CreateInfoKHR>(out);
+    if (auto* chain_struct = vku::FindStructInPNextChain<VkImageCreateFlags2CreateInfoKHR>(in_pnext_chain)) {
+        auto& out_chain_struct = std::get<VkImageCreateFlags2CreateInfoKHR>(out);
         out_chain_struct = *chain_struct;
         out_chain_struct.pNext = nullptr;
         if (!chain_begin) {
@@ -4314,8 +4314,8 @@ void *PnextChainExtract(const void *in_pnext_chain, PnextChainVkPhysicalDeviceIm
         }
     }
 
-    if (auto *chain_struct = vku::FindStructInPNextChain<VkImageFormatListCreateInfo>(in_pnext_chain)) {
-        auto &out_chain_struct = std::get<VkImageFormatListCreateInfo>(out);
+    if (auto* chain_struct = vku::FindStructInPNextChain<VkImageFormatListCreateInfo>(in_pnext_chain)) {
+        auto& out_chain_struct = std::get<VkImageFormatListCreateInfo>(out);
         out_chain_struct = *chain_struct;
         out_chain_struct.pNext = nullptr;
         if (!chain_begin) {
@@ -4326,8 +4326,8 @@ void *PnextChainExtract(const void *in_pnext_chain, PnextChainVkPhysicalDeviceIm
         }
     }
 
-    if (auto *chain_struct = vku::FindStructInPNextChain<VkImageStencilUsage2CreateInfoKHR>(in_pnext_chain)) {
-        auto &out_chain_struct = std::get<VkImageStencilUsage2CreateInfoKHR>(out);
+    if (auto* chain_struct = vku::FindStructInPNextChain<VkImageStencilUsage2CreateInfoKHR>(in_pnext_chain)) {
+        auto& out_chain_struct = std::get<VkImageStencilUsage2CreateInfoKHR>(out);
         out_chain_struct = *chain_struct;
         out_chain_struct.pNext = nullptr;
         if (!chain_begin) {
@@ -4338,8 +4338,8 @@ void *PnextChainExtract(const void *in_pnext_chain, PnextChainVkPhysicalDeviceIm
         }
     }
 
-    if (auto *chain_struct = vku::FindStructInPNextChain<VkImageStencilUsageCreateInfo>(in_pnext_chain)) {
-        auto &out_chain_struct = std::get<VkImageStencilUsageCreateInfo>(out);
+    if (auto* chain_struct = vku::FindStructInPNextChain<VkImageStencilUsageCreateInfo>(in_pnext_chain)) {
+        auto& out_chain_struct = std::get<VkImageStencilUsageCreateInfo>(out);
         out_chain_struct = *chain_struct;
         out_chain_struct.pNext = nullptr;
         if (!chain_begin) {
@@ -4350,8 +4350,8 @@ void *PnextChainExtract(const void *in_pnext_chain, PnextChainVkPhysicalDeviceIm
         }
     }
 
-    if (auto *chain_struct = vku::FindStructInPNextChain<VkImageUsageFlags2CreateInfoKHR>(in_pnext_chain)) {
-        auto &out_chain_struct = std::get<VkImageUsageFlags2CreateInfoKHR>(out);
+    if (auto* chain_struct = vku::FindStructInPNextChain<VkImageUsageFlags2CreateInfoKHR>(in_pnext_chain)) {
+        auto& out_chain_struct = std::get<VkImageUsageFlags2CreateInfoKHR>(out);
         out_chain_struct = *chain_struct;
         out_chain_struct.pNext = nullptr;
         if (!chain_begin) {
@@ -4362,8 +4362,8 @@ void *PnextChainExtract(const void *in_pnext_chain, PnextChainVkPhysicalDeviceIm
         }
     }
 
-    if (auto *chain_struct = vku::FindStructInPNextChain<VkOpticalFlowImageFormatInfoNV>(in_pnext_chain)) {
-        auto &out_chain_struct = std::get<VkOpticalFlowImageFormatInfoNV>(out);
+    if (auto* chain_struct = vku::FindStructInPNextChain<VkOpticalFlowImageFormatInfoNV>(in_pnext_chain)) {
+        auto& out_chain_struct = std::get<VkOpticalFlowImageFormatInfoNV>(out);
         out_chain_struct = *chain_struct;
         out_chain_struct.pNext = nullptr;
         if (!chain_begin) {
@@ -4374,8 +4374,8 @@ void *PnextChainExtract(const void *in_pnext_chain, PnextChainVkPhysicalDeviceIm
         }
     }
 
-    if (auto *chain_struct = vku::FindStructInPNextChain<VkPhysicalDeviceExternalImageFormatInfo>(in_pnext_chain)) {
-        auto &out_chain_struct = std::get<VkPhysicalDeviceExternalImageFormatInfo>(out);
+    if (auto* chain_struct = vku::FindStructInPNextChain<VkPhysicalDeviceExternalImageFormatInfo>(in_pnext_chain)) {
+        auto& out_chain_struct = std::get<VkPhysicalDeviceExternalImageFormatInfo>(out);
         out_chain_struct = *chain_struct;
         out_chain_struct.pNext = nullptr;
         if (!chain_begin) {
@@ -4386,8 +4386,8 @@ void *PnextChainExtract(const void *in_pnext_chain, PnextChainVkPhysicalDeviceIm
         }
     }
 
-    if (auto *chain_struct = vku::FindStructInPNextChain<VkPhysicalDeviceImageDrmFormatModifierInfoEXT>(in_pnext_chain)) {
-        auto &out_chain_struct = std::get<VkPhysicalDeviceImageDrmFormatModifierInfoEXT>(out);
+    if (auto* chain_struct = vku::FindStructInPNextChain<VkPhysicalDeviceImageDrmFormatModifierInfoEXT>(in_pnext_chain)) {
+        auto& out_chain_struct = std::get<VkPhysicalDeviceImageDrmFormatModifierInfoEXT>(out);
         out_chain_struct = *chain_struct;
         out_chain_struct.pNext = nullptr;
         if (!chain_begin) {
@@ -4398,8 +4398,8 @@ void *PnextChainExtract(const void *in_pnext_chain, PnextChainVkPhysicalDeviceIm
         }
     }
 
-    if (auto *chain_struct = vku::FindStructInPNextChain<VkPhysicalDeviceImageViewImageFormatInfoEXT>(in_pnext_chain)) {
-        auto &out_chain_struct = std::get<VkPhysicalDeviceImageViewImageFormatInfoEXT>(out);
+    if (auto* chain_struct = vku::FindStructInPNextChain<VkPhysicalDeviceImageViewImageFormatInfoEXT>(in_pnext_chain)) {
+        auto& out_chain_struct = std::get<VkPhysicalDeviceImageViewImageFormatInfoEXT>(out);
         out_chain_struct = *chain_struct;
         out_chain_struct.pNext = nullptr;
         if (!chain_begin) {
@@ -4410,8 +4410,8 @@ void *PnextChainExtract(const void *in_pnext_chain, PnextChainVkPhysicalDeviceIm
         }
     }
 
-    if (auto *chain_struct = vku::FindStructInPNextChain<VkVideoProfileListInfoKHR>(in_pnext_chain)) {
-        auto &out_chain_struct = std::get<VkVideoProfileListInfoKHR>(out);
+    if (auto* chain_struct = vku::FindStructInPNextChain<VkVideoProfileListInfoKHR>(in_pnext_chain)) {
+        auto& out_chain_struct = std::get<VkVideoProfileListInfoKHR>(out);
         out_chain_struct = *chain_struct;
         out_chain_struct.pNext = nullptr;
         if (!chain_begin) {
diff --git a/layers/vulkansc/generated/pnext_chain_extraction.h b/layers/vulkansc/generated/pnext_chain_extraction.h
index f9cadfc87..c5f13f0bd 100644
--- a/layers/vulkansc/generated/pnext_chain_extraction.h
+++ b/layers/vulkansc/generated/pnext_chain_extraction.h
@@ -32,22 +32,22 @@
 namespace vvl {
 
 // Add element to the end of a pNext chain
-void *PnextChainAdd(void *chain, void *new_struct);
+void* PnextChainAdd(void* chain, void* new_struct);
 
 // Remove last element from a pNext chain
-void PnextChainRemoveLast(void *chain);
+void PnextChainRemoveLast(void* chain);
 
 // Free dynamically allocated pnext chain structs
-void PnextChainFree(void *chain);
+void PnextChainFree(void* chain);
 
 // Helper class relying on RAII to help with adding and removing an element from a pNext chain
 class PnextChainScopedAdd {
   public:
-    PnextChainScopedAdd(void *chain, void *new_struct) : chain(chain) { PnextChainAdd(chain, new_struct); }
+    PnextChainScopedAdd(void* chain, void* new_struct) : chain(chain) { PnextChainAdd(chain, new_struct); }
     ~PnextChainScopedAdd() { PnextChainRemoveLast(chain); }
 
   private:
-    void *chain = nullptr;
+    void* chain = nullptr;
 };
 
 // clang-format off
diff --git a/layers/vulkansc/generated/spirv_validation_helper.cpp b/layers/vulkansc/generated/spirv_validation_helper.cpp
index c81e178eb..44b52a46b 100644
--- a/layers/vulkansc/generated/spirv_validation_helper.cpp
+++ b/layers/vulkansc/generated/spirv_validation_helper.cpp
@@ -45,14 +45,14 @@ struct FeaturePointer {
     // Default and nullptr constructor to create an empty FeaturePointer
     FeaturePointer() : IsEnabled(nullptr) {}
     FeaturePointer(std::nullptr_t ptr) : IsEnabled(nullptr) {}
-    FeaturePointer(bool DeviceFeatures::*ptr) : IsEnabled([=](const DeviceFeatures& features) { return features.*ptr; }) {}
+    FeaturePointer(bool DeviceFeatures::* ptr) : IsEnabled([=](const DeviceFeatures& features) { return features.*ptr; }) {}
 };
 
 // Each instance of the struct will only have a singel field non-null
 struct RequiredSpirvInfo {
     uint32_t version;
     FeaturePointer feature;
-    ExtEnabled DeviceExtensions::*extension;
+    ExtEnabled DeviceExtensions::* extension;
     const char* property;  // For human readability and make some capabilities unique
 };
 
diff --git a/layers/vulkansc/generated/vk_extension_helper.h b/layers/vulkansc/generated/vk_extension_helper.h
index 76cf48055..6634f5cb2 100644
--- a/layers/vulkansc/generated/vk_extension_helper.h
+++ b/layers/vulkansc/generated/vk_extension_helper.h
@@ -51,9 +51,9 @@ enum ExtEnabled : unsigned char {
 // Map of promoted extension information per version (a separate map exists for instance and device extensions).
 // The map is keyed by the version number (e.g. VK_API_VERSION_1_1) and each value is a pair consisting of the
 // version string (e.g. "VK_VERSION_1_1") and the set of name of the promoted extensions.
-using PromotedExtensionInfoMap = vvl::unordered_map<uint32_t, std::pair<const char *, vvl::unordered_set<vvl::Extension>>>;
-const PromotedExtensionInfoMap &GetInstancePromotionInfoMap();
-const PromotedExtensionInfoMap &GetDevicePromotionInfoMap();
+using PromotedExtensionInfoMap = vvl::unordered_map<uint32_t, std::pair<const char*, vvl::unordered_set<vvl::Extension>>>;
+const PromotedExtensionInfoMap& GetInstancePromotionInfoMap();
+const PromotedExtensionInfoMap& GetDevicePromotionInfoMap();
 
 /*
 This function is a helper to know if the extension is enabled.
@@ -136,23 +136,23 @@ struct InstanceExtensions {
     ExtEnabled vk_sec_ubm_surface{kNotSupported};
 
     struct Requirement {
-        const ExtEnabled InstanceExtensions::*enabled;
-        const char *name;
+        const ExtEnabled InstanceExtensions::* enabled;
+        const char* name;
     };
     // Only one requirement needs to be satisfied
     using RequirementOrGroup = small_vector<Requirement, 1>;
     using RequirementVec = std::vector<RequirementOrGroup>;
     struct Info {
-        Info(ExtEnabled InstanceExtensions::*state_, const RequirementVec requirements_)
+        Info(ExtEnabled InstanceExtensions::* state_, const RequirementVec requirements_)
             : state(state_), requirements(requirements_) {}
-        ExtEnabled InstanceExtensions::*state;
+        ExtEnabled InstanceExtensions::* state;
         RequirementVec requirements;
     };
 
-    const Info &GetInfo(vvl::Extension extension_name) const;
+    const Info& GetInfo(vvl::Extension extension_name) const;
 
     InstanceExtensions() = default;
-    InstanceExtensions(APIVersion requested_api_version, const VkInstanceCreateInfo *pCreateInfo);
+    InstanceExtensions(APIVersion requested_api_version, const VkInstanceCreateInfo* pCreateInfo);
 };
 
 struct DeviceExtensions : public InstanceExtensions {
@@ -595,32 +595,32 @@ struct DeviceExtensions : public InstanceExtensions {
     ExtEnabled vk_ext_mesh_shader{kNotSupported};
 
     struct Requirement {
-        const ExtEnabled DeviceExtensions::*enabled;
-        const char *name;
+        const ExtEnabled DeviceExtensions::* enabled;
+        const char* name;
     };
     // Only one requirement needs to be satisfied
     using RequirementOrGroup = std::vector<Requirement>;
     using RequirementVec = std::vector<RequirementOrGroup>;
     struct Info {
-        Info(ExtEnabled DeviceExtensions::*state_, const RequirementVec requirements_)
+        Info(ExtEnabled DeviceExtensions::* state_, const RequirementVec requirements_)
             : state(state_), requirements(requirements_) {}
-        ExtEnabled DeviceExtensions::*state;
+        ExtEnabled DeviceExtensions::* state;
         RequirementVec requirements;
     };
 
-    const Info &GetInfo(vvl::Extension extension_name) const;
+    const Info& GetInfo(vvl::Extension extension_name) const;
 
     DeviceExtensions() = default;
-    DeviceExtensions(const InstanceExtensions &instance_ext) : InstanceExtensions(instance_ext) {}
+    DeviceExtensions(const InstanceExtensions& instance_ext) : InstanceExtensions(instance_ext) {}
 
-    DeviceExtensions(const InstanceExtensions &instance_extensions, APIVersion requested_api_version,
-                     const VkDeviceCreateInfo *pCreateInfo = nullptr);
-    DeviceExtensions(const InstanceExtensions &instance_ext, APIVersion requested_api_version,
-                     const std::vector<VkExtensionProperties> &props);
+    DeviceExtensions(const InstanceExtensions& instance_extensions, APIVersion requested_api_version,
+                     const VkDeviceCreateInfo* pCreateInfo = nullptr);
+    DeviceExtensions(const InstanceExtensions& instance_ext, APIVersion requested_api_version,
+                     const std::vector<VkExtensionProperties>& props);
 };
 
-const InstanceExtensions::Info &GetInstanceVersionMap(const char *version);
-const DeviceExtensions::Info &GetDeviceVersionMap(const char *version);
+const InstanceExtensions::Info& GetInstanceVersionMap(const char* version);
+const DeviceExtensions::Info& GetDeviceVersionMap(const char* version);
 
 constexpr bool IsInstanceExtension(vvl::Extension extension) {
     switch (extension) {