add tools/Vulkan-Tools

41 files changed, 20119 insertions, 0 deletions

diff --git a/tools/Vulkan-Tools/vulkaninfo/BUILD.gn b/tools/Vulkan-Tools/vulkaninfo/BUILD.gn
new file mode 100644
index 00000000..9f460ca8
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/BUILD.gn
@@ -0,0 +1,78 @@
+# Copyright (C) 2025 The Fuchsia Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build_overrides/vulkan_tools.gni")
+if (is_fuchsia) {
+  import("//build/components.gni")
+  import("//src/lib/vulkan/vulkan.gni")
+}
+
+config("vulkaninfo_warnings") {
+  cflags = [
+    "-Wno-conversion",
+    "-Wno-implicit-fallthrough",
+    "-Wno-missing-field-initializers",
+    "-Wno-extra-semi",
+    "-Wno-ambiguous-reversed-operator",
+  ]
+}
+
+executable("vulkaninfo") {
+  sources = [ "vulkaninfo.cpp" ]
+
+  include_dirs = [
+    ".",
+    "generated",
+  ]
+
+  deps = [ "$vulkan_headers_dir:vulkan_headers" ]
+  if (is_fuchsia) {
+    deps += [ "//third_party/Vulkan-Loader:libvulkan" ]
+  }
+
+  configs += [
+    ":vulkaninfo_warnings",
+  ]
+  if (is_fuchsia) {
+    configs -= [ "//build/config:no_exceptions" ]
+  }
+
+  defines = [
+    "VK_ENABLE_BETA_EXTENSIONS",
+    "VK_NO_PROTOTYPES",
+  ]
+}
+
+if (is_fuchsia) {
+  fuchsia_test_component("vulkaninfo-component") {
+    manifest = "fuchsia/meta/vulkaninfo.cml"
+    component_name = "vulkaninfo"
+
+    deps = [
+      ":vulkaninfo",
+      "//src/lib/vulkan/swapchain:image_pipe_swapchain_fb_layer",
+      "//src/lib/vulkan/validation_layers",
+    ]
+    test_type = "vulkan"
+  }
+
+  fuchsia_test_package("vulkaninfo-package") {
+    package_name = "vulkaninfo"
+    test_components = [ ":vulkaninfo-component" ]
+
+    test_specs = {
+      environments = vulkan_envs
+    }
+  }
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/CMakeLists.txt b/tools/Vulkan-Tools/vulkaninfo/CMakeLists.txt
new file mode 100644
index 00000000..ed61c89f
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/CMakeLists.txt
@@ -0,0 +1,130 @@
+# ~~~
+# Copyright (c) 2018-2023 Valve Corporation
+# Copyright (c) 2018-2023 LunarG, Inc.
+# Copyright (c) 2023-2023 RasterGrid Kft.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ~~~
+
+# These variables enable downstream users to customize the CMake targets
+# based on the target API variant (e.g. Vulkan SC)
+set(VULKANINFO_NAME vulkaninfo)
+set(GENERATED generated)
+
+add_executable(vulkaninfo)
+set_target_properties(vulkaninfo PROPERTIES OUTPUT_NAME ${VULKANINFO_NAME})
+
+target_sources(vulkaninfo PRIVATE vulkaninfo.cpp)
+
+# Setup the vulkaninfo.rc file to contain the correct info
+# Optionally uses the VULKANINFO_BUILD_DLL_VERSIONINFO build option to allow setting the exact build version
+# When VULKANINFO_BUILD_DLL_VERSIONINFO is not provided, "Dev Build" is added to the version strings
+if(WIN32)
+    set(VULKANINFO_BUILD_DLL_VERSIONINFO "default" CACHE STRING "Set the version to be used in the vulkaninfo.rc file")
+
+    string(TIMESTAMP CURRENT_YEAR "%Y")
+    set(VULKANINFO_CUR_COPYRIGHT_STR "${CURRENT_YEAR}")
+    if ("$CACHE{VULKANINFO_BUILD_DLL_VERSIONINFO}" STREQUAL "default")
+        message(DEBUG "Setting RC version based on VulkanHeaders Version")
+        set(VULKANINFO_RC_VERSION "${VulkanHeaders_VERSION}")
+        set(VULKANINFO_VER_FILE_VERSION_STR "\"${VULKANINFO_RC_VERSION}.Dev Build\"")
+        set(VULKANINFO_VER_FILE_DESCRIPTION_STR "\"Vulkaninfo - Dev Build\"")
+    else()
+        message(DEBUG "Setting RC version based on VULKANINFO_BUILD_DLL_VERSIONINFO")
+        set(VULKANINFO_RC_VERSION "$CACHE{VULKANINFO_BUILD_DLL_VERSIONINFO}")
+        set(VULKANINFO_VER_FILE_VERSION_STR "\"${VULKANINFO_RC_VERSION}\"")
+        set(VULKANINFO_VER_FILE_DESCRIPTION_STR "\"vulkaninfo\"")
+    endif()
+
+    # RC file wants the value of FILEVERSION to separated by commas
+    string(REPLACE "." ", " VULKANINFO_VER_FILE_VERSION "${VULKANINFO_RC_VERSION}")
+
+    # Configure the file to include the versioning info
+    configure_file(vulkaninfo.rc.in ${CMAKE_CURRENT_BINARY_DIR}/vulkaninfo.rc)
+
+    target_sources(vulkaninfo PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/vulkaninfo.rc)
+endif()
+
+target_include_directories(vulkaninfo PRIVATE
+    ${GENERATED}
+    .
+)
+
+target_compile_definitions(vulkaninfo PRIVATE VK_ENABLE_BETA_EXTENSIONS VK_NO_PROTOTYPES)
+
+if (CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
+    option(BUILD_WSI_XCB_SUPPORT "Build XCB WSI support" ON)
+    option(BUILD_WSI_XLIB_SUPPORT "Build Xlib WSI support" ON)
+    option(BUILD_WSI_WAYLAND_SUPPORT "Build Wayland WSI support" ON)
+    option(BUILD_WSI_DIRECTFB_SUPPORT "Build DirectFB WSI support" OFF)
+
+    find_package(PkgConfig REQUIRED QUIET) # Use PkgConfig to find Linux system libraries
+
+    if(BUILD_WSI_XCB_SUPPORT)
+        pkg_check_modules(XCB REQUIRED QUIET IMPORTED_TARGET xcb)
+        target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_XCB_KHR)
+        target_link_libraries(vulkaninfo PRIVATE PkgConfig::XCB)
+    endif()
+
+    if(BUILD_WSI_XLIB_SUPPORT)
+        pkg_check_modules(X11 REQUIRED QUIET IMPORTED_TARGET x11)
+        target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_XLIB_KHR)
+        target_link_libraries(vulkaninfo PRIVATE PkgConfig::X11)
+    endif()
+
+    if(BUILD_WSI_WAYLAND_SUPPORT)
+        pkg_check_modules(WAYLAND_CLIENT REQUIRED IMPORTED_TARGET wayland-client)
+        target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_WAYLAND_KHR)
+        target_link_libraries(vulkaninfo PRIVATE PkgConfig::WAYLAND_CLIENT)
+    endif()
+
+    if(BUILD_WSI_DIRECTFB_SUPPORT)
+        pkg_check_modules(DirectFB REQUIRED QUIET IMPORTED_TARGET directfb)
+        target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_DIRECTFB_EXT)
+        target_link_libraries(vulkaninfo PRIVATE PkgConfig::DirectFB)
+    endif()
+    target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_DISPLAY)
+endif()
+
+if(APPLE)
+    # We do this so vulkaninfo is linked to an individual library and NOT a framework.
+    target_link_libraries(vulkaninfo PRIVATE "-framework AppKit -framework QuartzCore")
+    target_include_directories(vulkaninfo PRIVATE macOS/vulkaninfo)
+
+    target_sources(vulkaninfo PRIVATE
+        macOS/vulkaninfo/metal_view.mm
+        macOS/vulkaninfo/metal_view.h
+    )
+endif()
+
+target_link_libraries(vulkaninfo PRIVATE
+    Vulkan::Headers
+    ${CMAKE_DL_LIBS}
+)
+
+if(WIN32)
+    target_compile_definitions(vulkaninfo PRIVATE
+        VK_USE_PLATFORM_WIN32_KHR
+        WIN32_LEAN_AND_MEAN
+        _CRT_SECURE_NO_WARNINGS
+    )
+elseif(APPLE)
+    target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_METAL_EXT)
+    if (IOS)
+        target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_IOS_MVK)
+    else()
+        target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_MACOS_MVK)
+    endif()
+endif()
+
+install(TARGETS vulkaninfo)
diff --git a/tools/Vulkan-Tools/vulkaninfo/fuchsia/meta/vulkaninfo.cml b/tools/Vulkan-Tools/vulkaninfo/fuchsia/meta/vulkaninfo.cml
new file mode 100644
index 00000000..c7908172
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/fuchsia/meta/vulkaninfo.cml
@@ -0,0 +1,23 @@
+// Copyright (C) 2025 The Fuchsia Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+{
+    include: [
+        "sys/testing/elf_test_runner.shard.cml",
+        "syslog/client.shard.cml",
+        "vulkan/client.shard.cml",
+    ],
+    program: {
+        binary: "bin/vulkaninfo",
+    },
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/generated/.clang-format b/tools/Vulkan-Tools/vulkaninfo/generated/.clang-format
new file mode 100644
index 00000000..3bb983a4
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/generated/.clang-format
@@ -0,0 +1,5 @@
+---
+# Disable clang-format for generated code
+DisableFormat: true
+SortIncludes: false
+...
diff --git a/tools/Vulkan-Tools/vulkaninfo/generated/vulkaninfo.hpp b/tools/Vulkan-Tools/vulkaninfo/generated/vulkaninfo.hpp
new file mode 100644
index 00000000..2aaa17bb
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/generated/vulkaninfo.hpp
@@ -0,0 +1,13708 @@
+
+/*
+ * Copyright (c) 2019-2026 The Khronos Group Inc.
+ * Copyright (c) 2019-2026 Valve Corporation
+ * Copyright (c) 2019-2026 LunarG, Inc.
+ * Copyright (c) 2023-2024 RasterGrid Kft.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Charles Giessen <charles@lunarg.com>
+ *
+ */
+
+/*
+ * This file is generated from the Khronos Vulkan XML API Registry.
+ */
+
+#include "vulkaninfo.h"
+#include "outputprinter.h"
+
+template <typename T>
+std::string to_hex_str(const T i) {
+    std::stringstream stream;
+    stream << "0x" << std::setfill('0') << std::setw(sizeof(T)) << std::hex << i;
+    return stream.str();
+}
+
+template <typename T>
+std::string to_hex_str(Printer &p, const T i) {
+    if (p.Type() == OutputType::json)
+        return std::to_string(i);
+    else if (p.Type() == OutputType::vkconfig_output)
+        return std::string("\"") + to_hex_str(i) + std::string("\"");
+    else
+        return to_hex_str(i);
+}
+
+std::string StdVideoH264ChromaFormatIdcString(StdVideoH264ChromaFormatIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME:
+            return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME";
+        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_420:
+            return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_420";
+        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_422:
+            return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_422";
+        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_444:
+            return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_444";
+        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID:
+            return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264ChromaFormatIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264ChromaFormatIdc(Printer &p, std::string name, StdVideoH264ChromaFormatIdc value) {
+    p.PrintKeyString(name, StdVideoH264ChromaFormatIdcString(value));
+}
+std::string StdVideoH264ProfileIdcString(StdVideoH264ProfileIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_PROFILE_IDC_BASELINE:
+            return "STD_VIDEO_H264_PROFILE_IDC_BASELINE";
+        case STD_VIDEO_H264_PROFILE_IDC_MAIN:
+            return "STD_VIDEO_H264_PROFILE_IDC_MAIN";
+        case STD_VIDEO_H264_PROFILE_IDC_HIGH:
+            return "STD_VIDEO_H264_PROFILE_IDC_HIGH";
+        case STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE:
+            return "STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE";
+        case STD_VIDEO_H264_PROFILE_IDC_INVALID:
+            return "STD_VIDEO_H264_PROFILE_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264ProfileIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264ProfileIdc(Printer &p, std::string name, StdVideoH264ProfileIdc value) {
+    p.PrintKeyString(name, StdVideoH264ProfileIdcString(value));
+}
+std::string StdVideoH264LevelIdcString(StdVideoH264LevelIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_LEVEL_IDC_1_0:
+            return "STD_VIDEO_H264_LEVEL_IDC_1_0";
+        case STD_VIDEO_H264_LEVEL_IDC_1_1:
+            return "STD_VIDEO_H264_LEVEL_IDC_1_1";
+        case STD_VIDEO_H264_LEVEL_IDC_1_2:
+            return "STD_VIDEO_H264_LEVEL_IDC_1_2";
+        case STD_VIDEO_H264_LEVEL_IDC_1_3:
+            return "STD_VIDEO_H264_LEVEL_IDC_1_3";
+        case STD_VIDEO_H264_LEVEL_IDC_2_0:
+            return "STD_VIDEO_H264_LEVEL_IDC_2_0";
+        case STD_VIDEO_H264_LEVEL_IDC_2_1:
+            return "STD_VIDEO_H264_LEVEL_IDC_2_1";
+        case STD_VIDEO_H264_LEVEL_IDC_2_2:
+            return "STD_VIDEO_H264_LEVEL_IDC_2_2";
+        case STD_VIDEO_H264_LEVEL_IDC_3_0:
+            return "STD_VIDEO_H264_LEVEL_IDC_3_0";
+        case STD_VIDEO_H264_LEVEL_IDC_3_1:
+            return "STD_VIDEO_H264_LEVEL_IDC_3_1";
+        case STD_VIDEO_H264_LEVEL_IDC_3_2:
+            return "STD_VIDEO_H264_LEVEL_IDC_3_2";
+        case STD_VIDEO_H264_LEVEL_IDC_4_0:
+            return "STD_VIDEO_H264_LEVEL_IDC_4_0";
+        case STD_VIDEO_H264_LEVEL_IDC_4_1:
+            return "STD_VIDEO_H264_LEVEL_IDC_4_1";
+        case STD_VIDEO_H264_LEVEL_IDC_4_2:
+            return "STD_VIDEO_H264_LEVEL_IDC_4_2";
+        case STD_VIDEO_H264_LEVEL_IDC_5_0:
+            return "STD_VIDEO_H264_LEVEL_IDC_5_0";
+        case STD_VIDEO_H264_LEVEL_IDC_5_1:
+            return "STD_VIDEO_H264_LEVEL_IDC_5_1";
+        case STD_VIDEO_H264_LEVEL_IDC_5_2:
+            return "STD_VIDEO_H264_LEVEL_IDC_5_2";
+        case STD_VIDEO_H264_LEVEL_IDC_6_0:
+            return "STD_VIDEO_H264_LEVEL_IDC_6_0";
+        case STD_VIDEO_H264_LEVEL_IDC_6_1:
+            return "STD_VIDEO_H264_LEVEL_IDC_6_1";
+        case STD_VIDEO_H264_LEVEL_IDC_6_2:
+            return "STD_VIDEO_H264_LEVEL_IDC_6_2";
+        case STD_VIDEO_H264_LEVEL_IDC_INVALID:
+            return "STD_VIDEO_H264_LEVEL_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264LevelIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264LevelIdc(Printer &p, std::string name, StdVideoH264LevelIdc value) {
+    p.PrintKeyString(name, StdVideoH264LevelIdcString(value));
+}
+std::string StdVideoH264PocTypeString(StdVideoH264PocType value) {
+    switch (value) {
+        case STD_VIDEO_H264_POC_TYPE_0:
+            return "STD_VIDEO_H264_POC_TYPE_0";
+        case STD_VIDEO_H264_POC_TYPE_1:
+            return "STD_VIDEO_H264_POC_TYPE_1";
+        case STD_VIDEO_H264_POC_TYPE_2:
+            return "STD_VIDEO_H264_POC_TYPE_2";
+        case STD_VIDEO_H264_POC_TYPE_INVALID:
+            return "STD_VIDEO_H264_POC_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264PocType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264PocType(Printer &p, std::string name, StdVideoH264PocType value) {
+    p.PrintKeyString(name, StdVideoH264PocTypeString(value));
+}
+std::string StdVideoH264AspectRatioIdcString(StdVideoH264AspectRatioIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264AspectRatioIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264AspectRatioIdc(Printer &p, std::string name, StdVideoH264AspectRatioIdc value) {
+    p.PrintKeyString(name, StdVideoH264AspectRatioIdcString(value));
+}
+std::string StdVideoH264WeightedBipredIdcString(StdVideoH264WeightedBipredIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT:
+            return "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT";
+        case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT:
+            return "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT";
+        case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT:
+            return "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT";
+        case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID:
+            return "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264WeightedBipredIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264WeightedBipredIdc(Printer &p, std::string name, StdVideoH264WeightedBipredIdc value) {
+    p.PrintKeyString(name, StdVideoH264WeightedBipredIdcString(value));
+}
+std::string StdVideoH264ModificationOfPicNumsIdcString(StdVideoH264ModificationOfPicNumsIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT:
+            return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT";
+        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD:
+            return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD";
+        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM:
+            return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM";
+        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END:
+            return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END";
+        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID:
+            return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264ModificationOfPicNumsIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264ModificationOfPicNumsIdc(Printer &p, std::string name, StdVideoH264ModificationOfPicNumsIdc value) {
+    p.PrintKeyString(name, StdVideoH264ModificationOfPicNumsIdcString(value));
+}
+std::string StdVideoH264MemMgmtControlOpString(StdVideoH264MemMgmtControlOp value) {
+    switch (value) {
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264MemMgmtControlOp_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264MemMgmtControlOp(Printer &p, std::string name, StdVideoH264MemMgmtControlOp value) {
+    p.PrintKeyString(name, StdVideoH264MemMgmtControlOpString(value));
+}
+std::string StdVideoH264CabacInitIdcString(StdVideoH264CabacInitIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_CABAC_INIT_IDC_0:
+            return "STD_VIDEO_H264_CABAC_INIT_IDC_0";
+        case STD_VIDEO_H264_CABAC_INIT_IDC_1:
+            return "STD_VIDEO_H264_CABAC_INIT_IDC_1";
+        case STD_VIDEO_H264_CABAC_INIT_IDC_2:
+            return "STD_VIDEO_H264_CABAC_INIT_IDC_2";
+        case STD_VIDEO_H264_CABAC_INIT_IDC_INVALID:
+            return "STD_VIDEO_H264_CABAC_INIT_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264CabacInitIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264CabacInitIdc(Printer &p, std::string name, StdVideoH264CabacInitIdc value) {
+    p.PrintKeyString(name, StdVideoH264CabacInitIdcString(value));
+}
+std::string StdVideoH264DisableDeblockingFilterIdcString(StdVideoH264DisableDeblockingFilterIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED:
+            return "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED";
+        case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED:
+            return "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED";
+        case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL:
+            return "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL";
+        case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID:
+            return "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264DisableDeblockingFilterIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264DisableDeblockingFilterIdc(Printer &p, std::string name, StdVideoH264DisableDeblockingFilterIdc value) {
+    p.PrintKeyString(name, StdVideoH264DisableDeblockingFilterIdcString(value));
+}
+std::string StdVideoH264SliceTypeString(StdVideoH264SliceType value) {
+    switch (value) {
+        case STD_VIDEO_H264_SLICE_TYPE_P:
+            return "STD_VIDEO_H264_SLICE_TYPE_P";
+        case STD_VIDEO_H264_SLICE_TYPE_B:
+            return "STD_VIDEO_H264_SLICE_TYPE_B";
+        case STD_VIDEO_H264_SLICE_TYPE_I:
+            return "STD_VIDEO_H264_SLICE_TYPE_I";
+        case STD_VIDEO_H264_SLICE_TYPE_INVALID:
+            return "STD_VIDEO_H264_SLICE_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264SliceType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264SliceType(Printer &p, std::string name, StdVideoH264SliceType value) {
+    p.PrintKeyString(name, StdVideoH264SliceTypeString(value));
+}
+std::string StdVideoH264PictureTypeString(StdVideoH264PictureType value) {
+    switch (value) {
+        case STD_VIDEO_H264_PICTURE_TYPE_P:
+            return "STD_VIDEO_H264_PICTURE_TYPE_P";
+        case STD_VIDEO_H264_PICTURE_TYPE_B:
+            return "STD_VIDEO_H264_PICTURE_TYPE_B";
+        case STD_VIDEO_H264_PICTURE_TYPE_I:
+            return "STD_VIDEO_H264_PICTURE_TYPE_I";
+        case STD_VIDEO_H264_PICTURE_TYPE_IDR:
+            return "STD_VIDEO_H264_PICTURE_TYPE_IDR";
+        case STD_VIDEO_H264_PICTURE_TYPE_INVALID:
+            return "STD_VIDEO_H264_PICTURE_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264PictureType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264PictureType(Printer &p, std::string name, StdVideoH264PictureType value) {
+    p.PrintKeyString(name, StdVideoH264PictureTypeString(value));
+}
+std::string StdVideoH264NonVclNaluTypeString(StdVideoH264NonVclNaluType value) {
+    switch (value) {
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264NonVclNaluType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264NonVclNaluType(Printer &p, std::string name, StdVideoH264NonVclNaluType value) {
+    p.PrintKeyString(name, StdVideoH264NonVclNaluTypeString(value));
+}
+std::string StdVideoDecodeH264FieldOrderCountString(StdVideoDecodeH264FieldOrderCount value) {
+    switch (value) {
+        case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP:
+            return "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP";
+        case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM:
+            return "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM";
+        case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID:
+            return "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoDecodeH264FieldOrderCount_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoDecodeH264FieldOrderCount(Printer &p, std::string name, StdVideoDecodeH264FieldOrderCount value) {
+    p.PrintKeyString(name, StdVideoDecodeH264FieldOrderCountString(value));
+}
+std::string StdVideoH265ChromaFormatIdcString(StdVideoH265ChromaFormatIdc value) {
+    switch (value) {
+        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME:
+            return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME";
+        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_420:
+            return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_420";
+        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_422:
+            return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_422";
+        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_444:
+            return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_444";
+        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID:
+            return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH265ChromaFormatIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH265ChromaFormatIdc(Printer &p, std::string name, StdVideoH265ChromaFormatIdc value) {
+    p.PrintKeyString(name, StdVideoH265ChromaFormatIdcString(value));
+}
+std::string StdVideoH265ProfileIdcString(StdVideoH265ProfileIdc value) {
+    switch (value) {
+        case STD_VIDEO_H265_PROFILE_IDC_MAIN:
+            return "STD_VIDEO_H265_PROFILE_IDC_MAIN";
+        case STD_VIDEO_H265_PROFILE_IDC_MAIN_10:
+            return "STD_VIDEO_H265_PROFILE_IDC_MAIN_10";
+        case STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE:
+            return "STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE";
+        case STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS:
+            return "STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS";
+        case STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS:
+            return "STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS";
+        case STD_VIDEO_H265_PROFILE_IDC_INVALID:
+            return "STD_VIDEO_H265_PROFILE_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH265ProfileIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH265ProfileIdc(Printer &p, std::string name, StdVideoH265ProfileIdc value) {
+    p.PrintKeyString(name, StdVideoH265ProfileIdcString(value));
+}
+std::string StdVideoH265LevelIdcString(StdVideoH265LevelIdc value) {
+    switch (value) {
+        case STD_VIDEO_H265_LEVEL_IDC_1_0:
+            return "STD_VIDEO_H265_LEVEL_IDC_1_0";
+        case STD_VIDEO_H265_LEVEL_IDC_2_0:
+            return "STD_VIDEO_H265_LEVEL_IDC_2_0";
+        case STD_VIDEO_H265_LEVEL_IDC_2_1:
+            return "STD_VIDEO_H265_LEVEL_IDC_2_1";
+        case STD_VIDEO_H265_LEVEL_IDC_3_0:
+            return "STD_VIDEO_H265_LEVEL_IDC_3_0";
+        case STD_VIDEO_H265_LEVEL_IDC_3_1:
+            return "STD_VIDEO_H265_LEVEL_IDC_3_1";
+        case STD_VIDEO_H265_LEVEL_IDC_4_0:
+            return "STD_VIDEO_H265_LEVEL_IDC_4_0";
+        case STD_VIDEO_H265_LEVEL_IDC_4_1:
+            return "STD_VIDEO_H265_LEVEL_IDC_4_1";
+        case STD_VIDEO_H265_LEVEL_IDC_5_0:
+            return "STD_VIDEO_H265_LEVEL_IDC_5_0";
+        case STD_VIDEO_H265_LEVEL_IDC_5_1:
+            return "STD_VIDEO_H265_LEVEL_IDC_5_1";
+        case STD_VIDEO_H265_LEVEL_IDC_5_2:
+            return "STD_VIDEO_H265_LEVEL_IDC_5_2";
+        case STD_VIDEO_H265_LEVEL_IDC_6_0:
+            return "STD_VIDEO_H265_LEVEL_IDC_6_0";
+        case STD_VIDEO_H265_LEVEL_IDC_6_1:
+            return "STD_VIDEO_H265_LEVEL_IDC_6_1";
+        case STD_VIDEO_H265_LEVEL_IDC_6_2:
+            return "STD_VIDEO_H265_LEVEL_IDC_6_2";
+        case STD_VIDEO_H265_LEVEL_IDC_INVALID:
+            return "STD_VIDEO_H265_LEVEL_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH265LevelIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH265LevelIdc(Printer &p, std::string name, StdVideoH265LevelIdc value) {
+    p.PrintKeyString(name, StdVideoH265LevelIdcString(value));
+}
+std::string StdVideoH265SliceTypeString(StdVideoH265SliceType value) {
+    switch (value) {
+        case STD_VIDEO_H265_SLICE_TYPE_B:
+            return "STD_VIDEO_H265_SLICE_TYPE_B";
+        case STD_VIDEO_H265_SLICE_TYPE_P:
+            return "STD_VIDEO_H265_SLICE_TYPE_P";
+        case STD_VIDEO_H265_SLICE_TYPE_I:
+            return "STD_VIDEO_H265_SLICE_TYPE_I";
+        case STD_VIDEO_H265_SLICE_TYPE_INVALID:
+            return "STD_VIDEO_H265_SLICE_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH265SliceType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH265SliceType(Printer &p, std::string name, StdVideoH265SliceType value) {
+    p.PrintKeyString(name, StdVideoH265SliceTypeString(value));
+}
+std::string StdVideoH265PictureTypeString(StdVideoH265PictureType value) {
+    switch (value) {
+        case STD_VIDEO_H265_PICTURE_TYPE_P:
+            return "STD_VIDEO_H265_PICTURE_TYPE_P";
+        case STD_VIDEO_H265_PICTURE_TYPE_B:
+            return "STD_VIDEO_H265_PICTURE_TYPE_B";
+        case STD_VIDEO_H265_PICTURE_TYPE_I:
+            return "STD_VIDEO_H265_PICTURE_TYPE_I";
+        case STD_VIDEO_H265_PICTURE_TYPE_IDR:
+            return "STD_VIDEO_H265_PICTURE_TYPE_IDR";
+        case STD_VIDEO_H265_PICTURE_TYPE_INVALID:
+            return "STD_VIDEO_H265_PICTURE_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH265PictureType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH265PictureType(Printer &p, std::string name, StdVideoH265PictureType value) {
+    p.PrintKeyString(name, StdVideoH265PictureTypeString(value));
+}
+std::string StdVideoH265AspectRatioIdcString(StdVideoH265AspectRatioIdc value) {
+    switch (value) {
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH265AspectRatioIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH265AspectRatioIdc(Printer &p, std::string name, StdVideoH265AspectRatioIdc value) {
+    p.PrintKeyString(name, StdVideoH265AspectRatioIdcString(value));
+}
+std::string StdVideoAV1ProfileString(StdVideoAV1Profile value) {
+    switch (value) {
+        case STD_VIDEO_AV1_PROFILE_MAIN:
+            return "STD_VIDEO_AV1_PROFILE_MAIN";
+        case STD_VIDEO_AV1_PROFILE_HIGH:
+            return "STD_VIDEO_AV1_PROFILE_HIGH";
+        case STD_VIDEO_AV1_PROFILE_PROFESSIONAL:
+            return "STD_VIDEO_AV1_PROFILE_PROFESSIONAL";
+        case STD_VIDEO_AV1_PROFILE_INVALID:
+            return "STD_VIDEO_AV1_PROFILE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1Profile_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1Profile(Printer &p, std::string name, StdVideoAV1Profile value) {
+    p.PrintKeyString(name, StdVideoAV1ProfileString(value));
+}
+std::string StdVideoAV1LevelString(StdVideoAV1Level value) {
+    switch (value) {
+        case STD_VIDEO_AV1_LEVEL_2_0:
+            return "STD_VIDEO_AV1_LEVEL_2_0";
+        case STD_VIDEO_AV1_LEVEL_2_1:
+            return "STD_VIDEO_AV1_LEVEL_2_1";
+        case STD_VIDEO_AV1_LEVEL_2_2:
+            return "STD_VIDEO_AV1_LEVEL_2_2";
+        case STD_VIDEO_AV1_LEVEL_2_3:
+            return "STD_VIDEO_AV1_LEVEL_2_3";
+        case STD_VIDEO_AV1_LEVEL_3_0:
+            return "STD_VIDEO_AV1_LEVEL_3_0";
+        case STD_VIDEO_AV1_LEVEL_3_1:
+            return "STD_VIDEO_AV1_LEVEL_3_1";
+        case STD_VIDEO_AV1_LEVEL_3_2:
+            return "STD_VIDEO_AV1_LEVEL_3_2";
+        case STD_VIDEO_AV1_LEVEL_3_3:
+            return "STD_VIDEO_AV1_LEVEL_3_3";
+        case STD_VIDEO_AV1_LEVEL_4_0:
+            return "STD_VIDEO_AV1_LEVEL_4_0";
+        case STD_VIDEO_AV1_LEVEL_4_1:
+            return "STD_VIDEO_AV1_LEVEL_4_1";
+        case STD_VIDEO_AV1_LEVEL_4_2:
+            return "STD_VIDEO_AV1_LEVEL_4_2";
+        case STD_VIDEO_AV1_LEVEL_4_3:
+            return "STD_VIDEO_AV1_LEVEL_4_3";
+        case STD_VIDEO_AV1_LEVEL_5_0:
+            return "STD_VIDEO_AV1_LEVEL_5_0";
+        case STD_VIDEO_AV1_LEVEL_5_1:
+            return "STD_VIDEO_AV1_LEVEL_5_1";
+        case STD_VIDEO_AV1_LEVEL_5_2:
+            return "STD_VIDEO_AV1_LEVEL_5_2";
+        case STD_VIDEO_AV1_LEVEL_5_3:
+            return "STD_VIDEO_AV1_LEVEL_5_3";
+        case STD_VIDEO_AV1_LEVEL_6_0:
+            return "STD_VIDEO_AV1_LEVEL_6_0";
+        case STD_VIDEO_AV1_LEVEL_6_1:
+            return "STD_VIDEO_AV1_LEVEL_6_1";
+        case STD_VIDEO_AV1_LEVEL_6_2:
+            return "STD_VIDEO_AV1_LEVEL_6_2";
+        case STD_VIDEO_AV1_LEVEL_6_3:
+            return "STD_VIDEO_AV1_LEVEL_6_3";
+        case STD_VIDEO_AV1_LEVEL_7_0:
+            return "STD_VIDEO_AV1_LEVEL_7_0";
+        case STD_VIDEO_AV1_LEVEL_7_1:
+            return "STD_VIDEO_AV1_LEVEL_7_1";
+        case STD_VIDEO_AV1_LEVEL_7_2:
+            return "STD_VIDEO_AV1_LEVEL_7_2";
+        case STD_VIDEO_AV1_LEVEL_7_3:
+            return "STD_VIDEO_AV1_LEVEL_7_3";
+        case STD_VIDEO_AV1_LEVEL_INVALID:
+            return "STD_VIDEO_AV1_LEVEL_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1Level_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1Level(Printer &p, std::string name, StdVideoAV1Level value) {
+    p.PrintKeyString(name, StdVideoAV1LevelString(value));
+}
+std::string StdVideoAV1FrameTypeString(StdVideoAV1FrameType value) {
+    switch (value) {
+        case STD_VIDEO_AV1_FRAME_TYPE_KEY:
+            return "STD_VIDEO_AV1_FRAME_TYPE_KEY";
+        case STD_VIDEO_AV1_FRAME_TYPE_INTER:
+            return "STD_VIDEO_AV1_FRAME_TYPE_INTER";
+        case STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY:
+            return "STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY";
+        case STD_VIDEO_AV1_FRAME_TYPE_SWITCH:
+            return "STD_VIDEO_AV1_FRAME_TYPE_SWITCH";
+        case STD_VIDEO_AV1_FRAME_TYPE_INVALID:
+            return "STD_VIDEO_AV1_FRAME_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1FrameType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1FrameType(Printer &p, std::string name, StdVideoAV1FrameType value) {
+    p.PrintKeyString(name, StdVideoAV1FrameTypeString(value));
+}
+std::string StdVideoAV1ReferenceNameString(StdVideoAV1ReferenceName value) {
+    switch (value) {
+        case STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_INVALID:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1ReferenceName_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1ReferenceName(Printer &p, std::string name, StdVideoAV1ReferenceName value) {
+    p.PrintKeyString(name, StdVideoAV1ReferenceNameString(value));
+}
+std::string StdVideoAV1InterpolationFilterString(StdVideoAV1InterpolationFilter value) {
+    switch (value) {
+        case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP:
+            return "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP";
+        case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH:
+            return "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH";
+        case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP:
+            return "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP";
+        case STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR:
+            return "STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR";
+        case STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE:
+            return "STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE";
+        case STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID:
+            return "STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1InterpolationFilter_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1InterpolationFilter(Printer &p, std::string name, StdVideoAV1InterpolationFilter value) {
+    p.PrintKeyString(name, StdVideoAV1InterpolationFilterString(value));
+}
+std::string StdVideoAV1TxModeString(StdVideoAV1TxMode value) {
+    switch (value) {
+        case STD_VIDEO_AV1_TX_MODE_ONLY_4X4:
+            return "STD_VIDEO_AV1_TX_MODE_ONLY_4X4";
+        case STD_VIDEO_AV1_TX_MODE_LARGEST:
+            return "STD_VIDEO_AV1_TX_MODE_LARGEST";
+        case STD_VIDEO_AV1_TX_MODE_SELECT:
+            return "STD_VIDEO_AV1_TX_MODE_SELECT";
+        case STD_VIDEO_AV1_TX_MODE_INVALID:
+            return "STD_VIDEO_AV1_TX_MODE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1TxMode_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1TxMode(Printer &p, std::string name, StdVideoAV1TxMode value) {
+    p.PrintKeyString(name, StdVideoAV1TxModeString(value));
+}
+std::string StdVideoAV1FrameRestorationTypeString(StdVideoAV1FrameRestorationType value) {
+    switch (value) {
+        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE:
+            return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE";
+        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER:
+            return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER";
+        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ:
+            return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ";
+        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE:
+            return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE";
+        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID:
+            return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1FrameRestorationType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1FrameRestorationType(Printer &p, std::string name, StdVideoAV1FrameRestorationType value) {
+    p.PrintKeyString(name, StdVideoAV1FrameRestorationTypeString(value));
+}
+std::string StdVideoAV1ColorPrimariesString(StdVideoAV1ColorPrimaries value) {
+    switch (value) {
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1ColorPrimaries_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1ColorPrimaries(Printer &p, std::string name, StdVideoAV1ColorPrimaries value) {
+    p.PrintKeyString(name, StdVideoAV1ColorPrimariesString(value));
+}
+std::string StdVideoAV1TransferCharacteristicsString(StdVideoAV1TransferCharacteristics value) {
+    switch (value) {
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1TransferCharacteristics_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1TransferCharacteristics(Printer &p, std::string name, StdVideoAV1TransferCharacteristics value) {
+    p.PrintKeyString(name, StdVideoAV1TransferCharacteristicsString(value));
+}
+std::string StdVideoAV1MatrixCoefficientsString(StdVideoAV1MatrixCoefficients value) {
+    switch (value) {
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1MatrixCoefficients_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1MatrixCoefficients(Printer &p, std::string name, StdVideoAV1MatrixCoefficients value) {
+    p.PrintKeyString(name, StdVideoAV1MatrixCoefficientsString(value));
+}
+std::string StdVideoAV1ChromaSamplePositionString(StdVideoAV1ChromaSamplePosition value) {
+    switch (value) {
+        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN:
+            return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN";
+        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL:
+            return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL";
+        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED:
+            return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED";
+        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED:
+            return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED";
+        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID:
+            return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1ChromaSamplePosition_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1ChromaSamplePosition(Printer &p, std::string name, StdVideoAV1ChromaSamplePosition value) {
+    p.PrintKeyString(name, StdVideoAV1ChromaSamplePositionString(value));
+}
+std::string StdVideoVP9ProfileString(StdVideoVP9Profile value) {
+    switch (value) {
+        case STD_VIDEO_VP9_PROFILE_0:
+            return "STD_VIDEO_VP9_PROFILE_0";
+        case STD_VIDEO_VP9_PROFILE_1:
+            return "STD_VIDEO_VP9_PROFILE_1";
+        case STD_VIDEO_VP9_PROFILE_2:
+            return "STD_VIDEO_VP9_PROFILE_2";
+        case STD_VIDEO_VP9_PROFILE_3:
+            return "STD_VIDEO_VP9_PROFILE_3";
+        case STD_VIDEO_VP9_PROFILE_INVALID:
+            return "STD_VIDEO_VP9_PROFILE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoVP9Profile_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoVP9Profile(Printer &p, std::string name, StdVideoVP9Profile value) {
+    p.PrintKeyString(name, StdVideoVP9ProfileString(value));
+}
+std::string StdVideoVP9LevelString(StdVideoVP9Level value) {
+    switch (value) {
+        case STD_VIDEO_VP9_LEVEL_1_0:
+            return "STD_VIDEO_VP9_LEVEL_1_0";
+        case STD_VIDEO_VP9_LEVEL_1_1:
+            return "STD_VIDEO_VP9_LEVEL_1_1";
+        case STD_VIDEO_VP9_LEVEL_2_0:
+            return "STD_VIDEO_VP9_LEVEL_2_0";
+        case STD_VIDEO_VP9_LEVEL_2_1:
+            return "STD_VIDEO_VP9_LEVEL_2_1";
+        case STD_VIDEO_VP9_LEVEL_3_0:
+            return "STD_VIDEO_VP9_LEVEL_3_0";
+        case STD_VIDEO_VP9_LEVEL_3_1:
+            return "STD_VIDEO_VP9_LEVEL_3_1";
+        case STD_VIDEO_VP9_LEVEL_4_0:
+            return "STD_VIDEO_VP9_LEVEL_4_0";
+        case STD_VIDEO_VP9_LEVEL_4_1:
+            return "STD_VIDEO_VP9_LEVEL_4_1";
+        case STD_VIDEO_VP9_LEVEL_5_0:
+            return "STD_VIDEO_VP9_LEVEL_5_0";
+        case STD_VIDEO_VP9_LEVEL_5_1:
+            return "STD_VIDEO_VP9_LEVEL_5_1";
+        case STD_VIDEO_VP9_LEVEL_5_2:
+            return "STD_VIDEO_VP9_LEVEL_5_2";
+        case STD_VIDEO_VP9_LEVEL_6_0:
+            return "STD_VIDEO_VP9_LEVEL_6_0";
+        case STD_VIDEO_VP9_LEVEL_6_1:
+            return "STD_VIDEO_VP9_LEVEL_6_1";
+        case STD_VIDEO_VP9_LEVEL_6_2:
+            return "STD_VIDEO_VP9_LEVEL_6_2";
+        case STD_VIDEO_VP9_LEVEL_INVALID:
+            return "STD_VIDEO_VP9_LEVEL_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoVP9Level_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoVP9Level(Printer &p, std::string name, StdVideoVP9Level value) {
+    p.PrintKeyString(name, StdVideoVP9LevelString(value));
+}
+std::string StdVideoVP9FrameTypeString(StdVideoVP9FrameType value) {
+    switch (value) {
+        case STD_VIDEO_VP9_FRAME_TYPE_KEY:
+            return "STD_VIDEO_VP9_FRAME_TYPE_KEY";
+        case STD_VIDEO_VP9_FRAME_TYPE_NON_KEY:
+            return "STD_VIDEO_VP9_FRAME_TYPE_NON_KEY";
+        case STD_VIDEO_VP9_FRAME_TYPE_INVALID:
+            return "STD_VIDEO_VP9_FRAME_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoVP9FrameType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoVP9FrameType(Printer &p, std::string name, StdVideoVP9FrameType value) {
+    p.PrintKeyString(name, StdVideoVP9FrameTypeString(value));
+}
+std::string StdVideoVP9ReferenceNameString(StdVideoVP9ReferenceName value) {
+    switch (value) {
+        case STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME:
+            return "STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME";
+        case STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME:
+            return "STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME";
+        case STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME:
+            return "STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME";
+        case STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME:
+            return "STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME";
+        case STD_VIDEO_VP9_REFERENCE_NAME_INVALID:
+            return "STD_VIDEO_VP9_REFERENCE_NAME_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoVP9ReferenceName_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoVP9ReferenceName(Printer &p, std::string name, StdVideoVP9ReferenceName value) {
+    p.PrintKeyString(name, StdVideoVP9ReferenceNameString(value));
+}
+std::string StdVideoVP9InterpolationFilterString(StdVideoVP9InterpolationFilter value) {
+    switch (value) {
+        case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP:
+            return "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP";
+        case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH:
+            return "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH";
+        case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP:
+            return "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP";
+        case STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR:
+            return "STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR";
+        case STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE:
+            return "STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE";
+        case STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID:
+            return "STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoVP9InterpolationFilter_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoVP9InterpolationFilter(Printer &p, std::string name, StdVideoVP9InterpolationFilter value) {
+    p.PrintKeyString(name, StdVideoVP9InterpolationFilterString(value));
+}
+std::string StdVideoVP9ColorSpaceString(StdVideoVP9ColorSpace value) {
+    switch (value) {
+        case STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN:
+            return "STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN";
+        case STD_VIDEO_VP9_COLOR_SPACE_BT_601:
+            return "STD_VIDEO_VP9_COLOR_SPACE_BT_601";
+        case STD_VIDEO_VP9_COLOR_SPACE_BT_709:
+            return "STD_VIDEO_VP9_COLOR_SPACE_BT_709";
+        case STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170:
+            return "STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170";
+        case STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240:
+            return "STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240";
+        case STD_VIDEO_VP9_COLOR_SPACE_BT_2020:
+            return "STD_VIDEO_VP9_COLOR_SPACE_BT_2020";
+        case STD_VIDEO_VP9_COLOR_SPACE_RESERVED:
+            return "STD_VIDEO_VP9_COLOR_SPACE_RESERVED";
+        case STD_VIDEO_VP9_COLOR_SPACE_RGB:
+            return "STD_VIDEO_VP9_COLOR_SPACE_RGB";
+        case STD_VIDEO_VP9_COLOR_SPACE_INVALID:
+            return "STD_VIDEO_VP9_COLOR_SPACE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoVP9ColorSpace_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoVP9ColorSpace(Printer &p, std::string name, StdVideoVP9ColorSpace value) {
+    p.PrintKeyString(name, StdVideoVP9ColorSpaceString(value));
+}
+std::string VkColorSpaceKHRString(VkColorSpaceKHR value) {
+    switch (value) {
+        case (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR):
+            return "COLOR_SPACE_SRGB_NONLINEAR_KHR";
+        case (VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT):
+            return "COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT";
+        case (VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT):
+            return "COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT";
+        case (VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT):
+            return "COLOR_SPACE_DISPLAY_P3_LINEAR_EXT";
+        case (VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT):
+            return "COLOR_SPACE_DCI_P3_NONLINEAR_EXT";
+        case (VK_COLOR_SPACE_BT709_LINEAR_EXT):
+            return "COLOR_SPACE_BT709_LINEAR_EXT";
+        case (VK_COLOR_SPACE_BT709_NONLINEAR_EXT):
+            return "COLOR_SPACE_BT709_NONLINEAR_EXT";
+        case (VK_COLOR_SPACE_BT2020_LINEAR_EXT):
+            return "COLOR_SPACE_BT2020_LINEAR_EXT";
+        case (VK_COLOR_SPACE_HDR10_ST2084_EXT):
+            return "COLOR_SPACE_HDR10_ST2084_EXT";
+        case (VK_COLOR_SPACE_DOLBYVISION_EXT):
+            return "COLOR_SPACE_DOLBYVISION_EXT";
+        case (VK_COLOR_SPACE_HDR10_HLG_EXT):
+            return "COLOR_SPACE_HDR10_HLG_EXT";
+        case (VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT):
+            return "COLOR_SPACE_ADOBERGB_LINEAR_EXT";
+        case (VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT):
+            return "COLOR_SPACE_ADOBERGB_NONLINEAR_EXT";
+        case (VK_COLOR_SPACE_PASS_THROUGH_EXT):
+            return "COLOR_SPACE_PASS_THROUGH_EXT";
+        case (VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT):
+            return "COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT";
+        case (VK_COLOR_SPACE_DISPLAY_NATIVE_AMD):
+            return "COLOR_SPACE_DISPLAY_NATIVE_AMD";
+        default:
+            return std::string("UNKNOWN_VkColorSpaceKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkColorSpaceKHR(Printer &p, std::string name, VkColorSpaceKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkColorSpaceKHRString(value));
+    else
+        p.PrintKeyString(name, VkColorSpaceKHRString(value));
+}
+std::string VkComponentSwizzleString(VkComponentSwizzle value) {
+    switch (value) {
+        case (VK_COMPONENT_SWIZZLE_IDENTITY):
+            return "COMPONENT_SWIZZLE_IDENTITY";
+        case (VK_COMPONENT_SWIZZLE_ZERO):
+            return "COMPONENT_SWIZZLE_ZERO";
+        case (VK_COMPONENT_SWIZZLE_ONE):
+            return "COMPONENT_SWIZZLE_ONE";
+        case (VK_COMPONENT_SWIZZLE_R):
+            return "COMPONENT_SWIZZLE_R";
+        case (VK_COMPONENT_SWIZZLE_G):
+            return "COMPONENT_SWIZZLE_G";
+        case (VK_COMPONENT_SWIZZLE_B):
+            return "COMPONENT_SWIZZLE_B";
+        case (VK_COMPONENT_SWIZZLE_A):
+            return "COMPONENT_SWIZZLE_A";
+        default:
+            return std::string("UNKNOWN_VkComponentSwizzle_value") + std::to_string(value);
+    }
+}
+void DumpVkComponentSwizzle(Printer &p, std::string name, VkComponentSwizzle value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkComponentSwizzleString(value));
+    else
+        p.PrintKeyString(name, VkComponentSwizzleString(value));
+}
+std::string VkComponentTypeKHRString(VkComponentTypeKHR value) {
+    switch (value) {
+        case (VK_COMPONENT_TYPE_FLOAT16_KHR):
+            return "COMPONENT_TYPE_FLOAT16_KHR";
+        case (VK_COMPONENT_TYPE_FLOAT32_KHR):
+            return "COMPONENT_TYPE_FLOAT32_KHR";
+        case (VK_COMPONENT_TYPE_FLOAT64_KHR):
+            return "COMPONENT_TYPE_FLOAT64_KHR";
+        case (VK_COMPONENT_TYPE_SINT8_KHR):
+            return "COMPONENT_TYPE_SINT8_KHR";
+        case (VK_COMPONENT_TYPE_SINT16_KHR):
+            return "COMPONENT_TYPE_SINT16_KHR";
+        case (VK_COMPONENT_TYPE_SINT32_KHR):
+            return "COMPONENT_TYPE_SINT32_KHR";
+        case (VK_COMPONENT_TYPE_SINT64_KHR):
+            return "COMPONENT_TYPE_SINT64_KHR";
+        case (VK_COMPONENT_TYPE_UINT8_KHR):
+            return "COMPONENT_TYPE_UINT8_KHR";
+        case (VK_COMPONENT_TYPE_UINT16_KHR):
+            return "COMPONENT_TYPE_UINT16_KHR";
+        case (VK_COMPONENT_TYPE_UINT32_KHR):
+            return "COMPONENT_TYPE_UINT32_KHR";
+        case (VK_COMPONENT_TYPE_UINT64_KHR):
+            return "COMPONENT_TYPE_UINT64_KHR";
+        case (VK_COMPONENT_TYPE_BFLOAT16_KHR):
+            return "COMPONENT_TYPE_BFLOAT16_KHR";
+        case (VK_COMPONENT_TYPE_SINT8_PACKED_NV):
+            return "COMPONENT_TYPE_SINT8_PACKED_NV";
+        case (VK_COMPONENT_TYPE_UINT8_PACKED_NV):
+            return "COMPONENT_TYPE_UINT8_PACKED_NV";
+        case (VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT):
+            return "COMPONENT_TYPE_FLOAT8_E4M3_EXT";
+        case (VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT):
+            return "COMPONENT_TYPE_FLOAT8_E5M2_EXT";
+        default:
+            return std::string("UNKNOWN_VkComponentTypeKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkComponentTypeKHR(Printer &p, std::string name, VkComponentTypeKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkComponentTypeKHRString(value));
+    else
+        p.PrintKeyString(name, VkComponentTypeKHRString(value));
+}
+std::string VkDefaultVertexAttributeValueKHRString(VkDefaultVertexAttributeValueKHR value) {
+    switch (value) {
+        case (VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR):
+            return "DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR";
+        case (VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR):
+            return "DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR";
+        default:
+            return std::string("UNKNOWN_VkDefaultVertexAttributeValueKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkDefaultVertexAttributeValueKHR(Printer &p, std::string name, VkDefaultVertexAttributeValueKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkDefaultVertexAttributeValueKHRString(value));
+    else
+        p.PrintKeyString(name, VkDefaultVertexAttributeValueKHRString(value));
+}
+std::string VkDriverIdString(VkDriverId value) {
+    switch (value) {
+        case (VK_DRIVER_ID_AMD_PROPRIETARY):
+            return "DRIVER_ID_AMD_PROPRIETARY";
+        case (VK_DRIVER_ID_AMD_OPEN_SOURCE):
+            return "DRIVER_ID_AMD_OPEN_SOURCE";
+        case (VK_DRIVER_ID_MESA_RADV):
+            return "DRIVER_ID_MESA_RADV";
+        case (VK_DRIVER_ID_NVIDIA_PROPRIETARY):
+            return "DRIVER_ID_NVIDIA_PROPRIETARY";
+        case (VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS):
+            return "DRIVER_ID_INTEL_PROPRIETARY_WINDOWS";
+        case (VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA):
+            return "DRIVER_ID_INTEL_OPEN_SOURCE_MESA";
+        case (VK_DRIVER_ID_IMAGINATION_PROPRIETARY):
+            return "DRIVER_ID_IMAGINATION_PROPRIETARY";
+        case (VK_DRIVER_ID_QUALCOMM_PROPRIETARY):
+            return "DRIVER_ID_QUALCOMM_PROPRIETARY";
+        case (VK_DRIVER_ID_ARM_PROPRIETARY):
+            return "DRIVER_ID_ARM_PROPRIETARY";
+        case (VK_DRIVER_ID_GOOGLE_SWIFTSHADER):
+            return "DRIVER_ID_GOOGLE_SWIFTSHADER";
+        case (VK_DRIVER_ID_GGP_PROPRIETARY):
+            return "DRIVER_ID_GGP_PROPRIETARY";
+        case (VK_DRIVER_ID_BROADCOM_PROPRIETARY):
+            return "DRIVER_ID_BROADCOM_PROPRIETARY";
+        case (VK_DRIVER_ID_MESA_LLVMPIPE):
+            return "DRIVER_ID_MESA_LLVMPIPE";
+        case (VK_DRIVER_ID_MOLTENVK):
+            return "DRIVER_ID_MOLTENVK";
+        case (VK_DRIVER_ID_COREAVI_PROPRIETARY):
+            return "DRIVER_ID_COREAVI_PROPRIETARY";
+        case (VK_DRIVER_ID_JUICE_PROPRIETARY):
+            return "DRIVER_ID_JUICE_PROPRIETARY";
+        case (VK_DRIVER_ID_VERISILICON_PROPRIETARY):
+            return "DRIVER_ID_VERISILICON_PROPRIETARY";
+        case (VK_DRIVER_ID_MESA_TURNIP):
+            return "DRIVER_ID_MESA_TURNIP";
+        case (VK_DRIVER_ID_MESA_V3DV):
+            return "DRIVER_ID_MESA_V3DV";
+        case (VK_DRIVER_ID_MESA_PANVK):
+            return "DRIVER_ID_MESA_PANVK";
+        case (VK_DRIVER_ID_SAMSUNG_PROPRIETARY):
+            return "DRIVER_ID_SAMSUNG_PROPRIETARY";
+        case (VK_DRIVER_ID_MESA_VENUS):
+            return "DRIVER_ID_MESA_VENUS";
+        case (VK_DRIVER_ID_MESA_DOZEN):
+            return "DRIVER_ID_MESA_DOZEN";
+        case (VK_DRIVER_ID_MESA_NVK):
+            return "DRIVER_ID_MESA_NVK";
+        case (VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA):
+            return "DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA";
+        case (VK_DRIVER_ID_MESA_HONEYKRISP):
+            return "DRIVER_ID_MESA_HONEYKRISP";
+        case (VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN):
+            return "DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN";
+        case (VK_DRIVER_ID_MESA_KOSMICKRISP):
+            return "DRIVER_ID_MESA_KOSMICKRISP";
+        default:
+            return std::string("UNKNOWN_VkDriverId_value") + std::to_string(value);
+    }
+}
+void DumpVkDriverId(Printer &p, std::string name, VkDriverId value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkDriverIdString(value));
+    else
+        p.PrintKeyString(name, VkDriverIdString(value));
+}
+std::string VkFormatString(VkFormat value) {
+    switch (value) {
+        case (VK_FORMAT_UNDEFINED):
+            return "FORMAT_UNDEFINED";
+        case (VK_FORMAT_R4G4_UNORM_PACK8):
+            return "FORMAT_R4G4_UNORM_PACK8";
+        case (VK_FORMAT_R4G4B4A4_UNORM_PACK16):
+            return "FORMAT_R4G4B4A4_UNORM_PACK16";
+        case (VK_FORMAT_B4G4R4A4_UNORM_PACK16):
+            return "FORMAT_B4G4R4A4_UNORM_PACK16";
+        case (VK_FORMAT_R5G6B5_UNORM_PACK16):
+            return "FORMAT_R5G6B5_UNORM_PACK16";
+        case (VK_FORMAT_B5G6R5_UNORM_PACK16):
+            return "FORMAT_B5G6R5_UNORM_PACK16";
+        case (VK_FORMAT_R5G5B5A1_UNORM_PACK16):
+            return "FORMAT_R5G5B5A1_UNORM_PACK16";
+        case (VK_FORMAT_B5G5R5A1_UNORM_PACK16):
+            return "FORMAT_B5G5R5A1_UNORM_PACK16";
+        case (VK_FORMAT_A1R5G5B5_UNORM_PACK16):
+            return "FORMAT_A1R5G5B5_UNORM_PACK16";
+        case (VK_FORMAT_R8_UNORM):
+            return "FORMAT_R8_UNORM";
+        case (VK_FORMAT_R8_SNORM):
+            return "FORMAT_R8_SNORM";
+        case (VK_FORMAT_R8_USCALED):
+            return "FORMAT_R8_USCALED";
+        case (VK_FORMAT_R8_SSCALED):
+            return "FORMAT_R8_SSCALED";
+        case (VK_FORMAT_R8_UINT):
+            return "FORMAT_R8_UINT";
+        case (VK_FORMAT_R8_SINT):
+            return "FORMAT_R8_SINT";
+        case (VK_FORMAT_R8_SRGB):
+            return "FORMAT_R8_SRGB";
+        case (VK_FORMAT_R8G8_UNORM):
+            return "FORMAT_R8G8_UNORM";
+        case (VK_FORMAT_R8G8_SNORM):
+            return "FORMAT_R8G8_SNORM";
+        case (VK_FORMAT_R8G8_USCALED):
+            return "FORMAT_R8G8_USCALED";
+        case (VK_FORMAT_R8G8_SSCALED):
+            return "FORMAT_R8G8_SSCALED";
+        case (VK_FORMAT_R8G8_UINT):
+            return "FORMAT_R8G8_UINT";
+        case (VK_FORMAT_R8G8_SINT):
+            return "FORMAT_R8G8_SINT";
+        case (VK_FORMAT_R8G8_SRGB):
+            return "FORMAT_R8G8_SRGB";
+        case (VK_FORMAT_R8G8B8_UNORM):
+            return "FORMAT_R8G8B8_UNORM";
+        case (VK_FORMAT_R8G8B8_SNORM):
+            return "FORMAT_R8G8B8_SNORM";
+        case (VK_FORMAT_R8G8B8_USCALED):
+            return "FORMAT_R8G8B8_USCALED";
+        case (VK_FORMAT_R8G8B8_SSCALED):
+            return "FORMAT_R8G8B8_SSCALED";
+        case (VK_FORMAT_R8G8B8_UINT):
+            return "FORMAT_R8G8B8_UINT";
+        case (VK_FORMAT_R8G8B8_SINT):
+            return "FORMAT_R8G8B8_SINT";
+        case (VK_FORMAT_R8G8B8_SRGB):
+            return "FORMAT_R8G8B8_SRGB";
+        case (VK_FORMAT_B8G8R8_UNORM):
+            return "FORMAT_B8G8R8_UNORM";
+        case (VK_FORMAT_B8G8R8_SNORM):
+            return "FORMAT_B8G8R8_SNORM";
+        case (VK_FORMAT_B8G8R8_USCALED):
+            return "FORMAT_B8G8R8_USCALED";
+        case (VK_FORMAT_B8G8R8_SSCALED):
+            return "FORMAT_B8G8R8_SSCALED";
+        case (VK_FORMAT_B8G8R8_UINT):
+            return "FORMAT_B8G8R8_UINT";
+        case (VK_FORMAT_B8G8R8_SINT):
+            return "FORMAT_B8G8R8_SINT";
+        case (VK_FORMAT_B8G8R8_SRGB):
+            return "FORMAT_B8G8R8_SRGB";
+        case (VK_FORMAT_R8G8B8A8_UNORM):
+            return "FORMAT_R8G8B8A8_UNORM";
+        case (VK_FORMAT_R8G8B8A8_SNORM):
+            return "FORMAT_R8G8B8A8_SNORM";
+        case (VK_FORMAT_R8G8B8A8_USCALED):
+            return "FORMAT_R8G8B8A8_USCALED";
+        case (VK_FORMAT_R8G8B8A8_SSCALED):
+            return "FORMAT_R8G8B8A8_SSCALED";
+        case (VK_FORMAT_R8G8B8A8_UINT):
+            return "FORMAT_R8G8B8A8_UINT";
+        case (VK_FORMAT_R8G8B8A8_SINT):
+            return "FORMAT_R8G8B8A8_SINT";
+        case (VK_FORMAT_R8G8B8A8_SRGB):
+            return "FORMAT_R8G8B8A8_SRGB";
+        case (VK_FORMAT_B8G8R8A8_UNORM):
+            return "FORMAT_B8G8R8A8_UNORM";
+        case (VK_FORMAT_B8G8R8A8_SNORM):
+            return "FORMAT_B8G8R8A8_SNORM";
+        case (VK_FORMAT_B8G8R8A8_USCALED):
+            return "FORMAT_B8G8R8A8_USCALED";
+        case (VK_FORMAT_B8G8R8A8_SSCALED):
+            return "FORMAT_B8G8R8A8_SSCALED";
+        case (VK_FORMAT_B8G8R8A8_UINT):
+            return "FORMAT_B8G8R8A8_UINT";
+        case (VK_FORMAT_B8G8R8A8_SINT):
+            return "FORMAT_B8G8R8A8_SINT";
+        case (VK_FORMAT_B8G8R8A8_SRGB):
+            return "FORMAT_B8G8R8A8_SRGB";
+        case (VK_FORMAT_A8B8G8R8_UNORM_PACK32):
+            return "FORMAT_A8B8G8R8_UNORM_PACK32";
+        case (VK_FORMAT_A8B8G8R8_SNORM_PACK32):
+            return "FORMAT_A8B8G8R8_SNORM_PACK32";
+        case (VK_FORMAT_A8B8G8R8_USCALED_PACK32):
+            return "FORMAT_A8B8G8R8_USCALED_PACK32";
+        case (VK_FORMAT_A8B8G8R8_SSCALED_PACK32):
+            return "FORMAT_A8B8G8R8_SSCALED_PACK32";
+        case (VK_FORMAT_A8B8G8R8_UINT_PACK32):
+            return "FORMAT_A8B8G8R8_UINT_PACK32";
+        case (VK_FORMAT_A8B8G8R8_SINT_PACK32):
+            return "FORMAT_A8B8G8R8_SINT_PACK32";
+        case (VK_FORMAT_A8B8G8R8_SRGB_PACK32):
+            return "FORMAT_A8B8G8R8_SRGB_PACK32";
+        case (VK_FORMAT_A2R10G10B10_UNORM_PACK32):
+            return "FORMAT_A2R10G10B10_UNORM_PACK32";
+        case (VK_FORMAT_A2R10G10B10_SNORM_PACK32):
+            return "FORMAT_A2R10G10B10_SNORM_PACK32";
+        case (VK_FORMAT_A2R10G10B10_USCALED_PACK32):
+            return "FORMAT_A2R10G10B10_USCALED_PACK32";
+        case (VK_FORMAT_A2R10G10B10_SSCALED_PACK32):
+            return "FORMAT_A2R10G10B10_SSCALED_PACK32";
+        case (VK_FORMAT_A2R10G10B10_UINT_PACK32):
+            return "FORMAT_A2R10G10B10_UINT_PACK32";
+        case (VK_FORMAT_A2R10G10B10_SINT_PACK32):
+            return "FORMAT_A2R10G10B10_SINT_PACK32";
+        case (VK_FORMAT_A2B10G10R10_UNORM_PACK32):
+            return "FORMAT_A2B10G10R10_UNORM_PACK32";
+        case (VK_FORMAT_A2B10G10R10_SNORM_PACK32):
+            return "FORMAT_A2B10G10R10_SNORM_PACK32";
+        case (VK_FORMAT_A2B10G10R10_USCALED_PACK32):
+            return "FORMAT_A2B10G10R10_USCALED_PACK32";
+        case (VK_FORMAT_A2B10G10R10_SSCALED_PACK32):
+            return "FORMAT_A2B10G10R10_SSCALED_PACK32";
+        case (VK_FORMAT_A2B10G10R10_UINT_PACK32):
+            return "FORMAT_A2B10G10R10_UINT_PACK32";
+        case (VK_FORMAT_A2B10G10R10_SINT_PACK32):
+            return "FORMAT_A2B10G10R10_SINT_PACK32";
+        case (VK_FORMAT_R16_UNORM):
+            return "FORMAT_R16_UNORM";
+        case (VK_FORMAT_R16_SNORM):
+            return "FORMAT_R16_SNORM";
+        case (VK_FORMAT_R16_USCALED):
+            return "FORMAT_R16_USCALED";
+        case (VK_FORMAT_R16_SSCALED):
+            return "FORMAT_R16_SSCALED";
+        case (VK_FORMAT_R16_UINT):
+            return "FORMAT_R16_UINT";
+        case (VK_FORMAT_R16_SINT):
+            return "FORMAT_R16_SINT";
+        case (VK_FORMAT_R16_SFLOAT):
+            return "FORMAT_R16_SFLOAT";
+        case (VK_FORMAT_R16G16_UNORM):
+            return "FORMAT_R16G16_UNORM";
+        case (VK_FORMAT_R16G16_SNORM):
+            return "FORMAT_R16G16_SNORM";
+        case (VK_FORMAT_R16G16_USCALED):
+            return "FORMAT_R16G16_USCALED";
+        case (VK_FORMAT_R16G16_SSCALED):
+            return "FORMAT_R16G16_SSCALED";
+        case (VK_FORMAT_R16G16_UINT):
+            return "FORMAT_R16G16_UINT";
+        case (VK_FORMAT_R16G16_SINT):
+            return "FORMAT_R16G16_SINT";
+        case (VK_FORMAT_R16G16_SFLOAT):
+            return "FORMAT_R16G16_SFLOAT";
+        case (VK_FORMAT_R16G16B16_UNORM):
+            return "FORMAT_R16G16B16_UNORM";
+        case (VK_FORMAT_R16G16B16_SNORM):
+            return "FORMAT_R16G16B16_SNORM";
+        case (VK_FORMAT_R16G16B16_USCALED):
+            return "FORMAT_R16G16B16_USCALED";
+        case (VK_FORMAT_R16G16B16_SSCALED):
+            return "FORMAT_R16G16B16_SSCALED";
+        case (VK_FORMAT_R16G16B16_UINT):
+            return "FORMAT_R16G16B16_UINT";
+        case (VK_FORMAT_R16G16B16_SINT):
+            return "FORMAT_R16G16B16_SINT";
+        case (VK_FORMAT_R16G16B16_SFLOAT):
+            return "FORMAT_R16G16B16_SFLOAT";
+        case (VK_FORMAT_R16G16B16A16_UNORM):
+            return "FORMAT_R16G16B16A16_UNORM";
+        case (VK_FORMAT_R16G16B16A16_SNORM):
+            return "FORMAT_R16G16B16A16_SNORM";
+        case (VK_FORMAT_R16G16B16A16_USCALED):
+            return "FORMAT_R16G16B16A16_USCALED";
+        case (VK_FORMAT_R16G16B16A16_SSCALED):
+            return "FORMAT_R16G16B16A16_SSCALED";
+        case (VK_FORMAT_R16G16B16A16_UINT):
+            return "FORMAT_R16G16B16A16_UINT";
+        case (VK_FORMAT_R16G16B16A16_SINT):
+            return "FORMAT_R16G16B16A16_SINT";
+        case (VK_FORMAT_R16G16B16A16_SFLOAT):
+            return "FORMAT_R16G16B16A16_SFLOAT";
+        case (VK_FORMAT_R32_UINT):
+            return "FORMAT_R32_UINT";
+        case (VK_FORMAT_R32_SINT):
+            return "FORMAT_R32_SINT";
+        case (VK_FORMAT_R32_SFLOAT):
+            return "FORMAT_R32_SFLOAT";
+        case (VK_FORMAT_R32G32_UINT):
+            return "FORMAT_R32G32_UINT";
+        case (VK_FORMAT_R32G32_SINT):
+            return "FORMAT_R32G32_SINT";
+        case (VK_FORMAT_R32G32_SFLOAT):
+            return "FORMAT_R32G32_SFLOAT";
+        case (VK_FORMAT_R32G32B32_UINT):
+            return "FORMAT_R32G32B32_UINT";
+        case (VK_FORMAT_R32G32B32_SINT):
+            return "FORMAT_R32G32B32_SINT";
+        case (VK_FORMAT_R32G32B32_SFLOAT):
+            return "FORMAT_R32G32B32_SFLOAT";
+        case (VK_FORMAT_R32G32B32A32_UINT):
+            return "FORMAT_R32G32B32A32_UINT";
+        case (VK_FORMAT_R32G32B32A32_SINT):
+            return "FORMAT_R32G32B32A32_SINT";
+        case (VK_FORMAT_R32G32B32A32_SFLOAT):
+            return "FORMAT_R32G32B32A32_SFLOAT";
+        case (VK_FORMAT_R64_UINT):
+            return "FORMAT_R64_UINT";
+        case (VK_FORMAT_R64_SINT):
+            return "FORMAT_R64_SINT";
+        case (VK_FORMAT_R64_SFLOAT):
+            return "FORMAT_R64_SFLOAT";
+        case (VK_FORMAT_R64G64_UINT):
+            return "FORMAT_R64G64_UINT";
+        case (VK_FORMAT_R64G64_SINT):
+            return "FORMAT_R64G64_SINT";
+        case (VK_FORMAT_R64G64_SFLOAT):
+            return "FORMAT_R64G64_SFLOAT";
+        case (VK_FORMAT_R64G64B64_UINT):
+            return "FORMAT_R64G64B64_UINT";
+        case (VK_FORMAT_R64G64B64_SINT):
+            return "FORMAT_R64G64B64_SINT";
+        case (VK_FORMAT_R64G64B64_SFLOAT):
+            return "FORMAT_R64G64B64_SFLOAT";
+        case (VK_FORMAT_R64G64B64A64_UINT):
+            return "FORMAT_R64G64B64A64_UINT";
+        case (VK_FORMAT_R64G64B64A64_SINT):
+            return "FORMAT_R64G64B64A64_SINT";
+        case (VK_FORMAT_R64G64B64A64_SFLOAT):
+            return "FORMAT_R64G64B64A64_SFLOAT";
+        case (VK_FORMAT_B10G11R11_UFLOAT_PACK32):
+            return "FORMAT_B10G11R11_UFLOAT_PACK32";
+        case (VK_FORMAT_E5B9G9R9_UFLOAT_PACK32):
+            return "FORMAT_E5B9G9R9_UFLOAT_PACK32";
+        case (VK_FORMAT_D16_UNORM):
+            return "FORMAT_D16_UNORM";
+        case (VK_FORMAT_X8_D24_UNORM_PACK32):
+            return "FORMAT_X8_D24_UNORM_PACK32";
+        case (VK_FORMAT_D32_SFLOAT):
+            return "FORMAT_D32_SFLOAT";
+        case (VK_FORMAT_S8_UINT):
+            return "FORMAT_S8_UINT";
+        case (VK_FORMAT_D16_UNORM_S8_UINT):
+            return "FORMAT_D16_UNORM_S8_UINT";
+        case (VK_FORMAT_D24_UNORM_S8_UINT):
+            return "FORMAT_D24_UNORM_S8_UINT";
+        case (VK_FORMAT_D32_SFLOAT_S8_UINT):
+            return "FORMAT_D32_SFLOAT_S8_UINT";
+        case (VK_FORMAT_BC1_RGB_UNORM_BLOCK):
+            return "FORMAT_BC1_RGB_UNORM_BLOCK";
+        case (VK_FORMAT_BC1_RGB_SRGB_BLOCK):
+            return "FORMAT_BC1_RGB_SRGB_BLOCK";
+        case (VK_FORMAT_BC1_RGBA_UNORM_BLOCK):
+            return "FORMAT_BC1_RGBA_UNORM_BLOCK";
+        case (VK_FORMAT_BC1_RGBA_SRGB_BLOCK):
+            return "FORMAT_BC1_RGBA_SRGB_BLOCK";
+        case (VK_FORMAT_BC2_UNORM_BLOCK):
+            return "FORMAT_BC2_UNORM_BLOCK";
+        case (VK_FORMAT_BC2_SRGB_BLOCK):
+            return "FORMAT_BC2_SRGB_BLOCK";
+        case (VK_FORMAT_BC3_UNORM_BLOCK):
+            return "FORMAT_BC3_UNORM_BLOCK";
+        case (VK_FORMAT_BC3_SRGB_BLOCK):
+            return "FORMAT_BC3_SRGB_BLOCK";
+        case (VK_FORMAT_BC4_UNORM_BLOCK):
+            return "FORMAT_BC4_UNORM_BLOCK";
+        case (VK_FORMAT_BC4_SNORM_BLOCK):
+            return "FORMAT_BC4_SNORM_BLOCK";
+        case (VK_FORMAT_BC5_UNORM_BLOCK):
+            return "FORMAT_BC5_UNORM_BLOCK";
+        case (VK_FORMAT_BC5_SNORM_BLOCK):
+            return "FORMAT_BC5_SNORM_BLOCK";
+        case (VK_FORMAT_BC6H_UFLOAT_BLOCK):
+            return "FORMAT_BC6H_UFLOAT_BLOCK";
+        case (VK_FORMAT_BC6H_SFLOAT_BLOCK):
+            return "FORMAT_BC6H_SFLOAT_BLOCK";
+        case (VK_FORMAT_BC7_UNORM_BLOCK):
+            return "FORMAT_BC7_UNORM_BLOCK";
+        case (VK_FORMAT_BC7_SRGB_BLOCK):
+            return "FORMAT_BC7_SRGB_BLOCK";
+        case (VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK):
+            return "FORMAT_ETC2_R8G8B8_UNORM_BLOCK";
+        case (VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK):
+            return "FORMAT_ETC2_R8G8B8_SRGB_BLOCK";
+        case (VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK):
+            return "FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK";
+        case (VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK):
+            return "FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK";
+        case (VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK):
+            return "FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK";
+        case (VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK):
+            return "FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK";
+        case (VK_FORMAT_EAC_R11_UNORM_BLOCK):
+            return "FORMAT_EAC_R11_UNORM_BLOCK";
+        case (VK_FORMAT_EAC_R11_SNORM_BLOCK):
+            return "FORMAT_EAC_R11_SNORM_BLOCK";
+        case (VK_FORMAT_EAC_R11G11_UNORM_BLOCK):
+            return "FORMAT_EAC_R11G11_UNORM_BLOCK";
+        case (VK_FORMAT_EAC_R11G11_SNORM_BLOCK):
+            return "FORMAT_EAC_R11G11_SNORM_BLOCK";
+        case (VK_FORMAT_ASTC_4x4_UNORM_BLOCK):
+            return "FORMAT_ASTC_4x4_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_4x4_SRGB_BLOCK):
+            return "FORMAT_ASTC_4x4_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_5x4_UNORM_BLOCK):
+            return "FORMAT_ASTC_5x4_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_5x4_SRGB_BLOCK):
+            return "FORMAT_ASTC_5x4_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_5x5_UNORM_BLOCK):
+            return "FORMAT_ASTC_5x5_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_5x5_SRGB_BLOCK):
+            return "FORMAT_ASTC_5x5_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_6x5_UNORM_BLOCK):
+            return "FORMAT_ASTC_6x5_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_6x5_SRGB_BLOCK):
+            return "FORMAT_ASTC_6x5_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_6x6_UNORM_BLOCK):
+            return "FORMAT_ASTC_6x6_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_6x6_SRGB_BLOCK):
+            return "FORMAT_ASTC_6x6_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_8x5_UNORM_BLOCK):
+            return "FORMAT_ASTC_8x5_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_8x5_SRGB_BLOCK):
+            return "FORMAT_ASTC_8x5_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_8x6_UNORM_BLOCK):
+            return "FORMAT_ASTC_8x6_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_8x6_SRGB_BLOCK):
+            return "FORMAT_ASTC_8x6_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_8x8_UNORM_BLOCK):
+            return "FORMAT_ASTC_8x8_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_8x8_SRGB_BLOCK):
+            return "FORMAT_ASTC_8x8_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_10x5_UNORM_BLOCK):
+            return "FORMAT_ASTC_10x5_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_10x5_SRGB_BLOCK):
+            return "FORMAT_ASTC_10x5_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_10x6_UNORM_BLOCK):
+            return "FORMAT_ASTC_10x6_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_10x6_SRGB_BLOCK):
+            return "FORMAT_ASTC_10x6_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_10x8_UNORM_BLOCK):
+            return "FORMAT_ASTC_10x8_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_10x8_SRGB_BLOCK):
+            return "FORMAT_ASTC_10x8_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_10x10_UNORM_BLOCK):
+            return "FORMAT_ASTC_10x10_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_10x10_SRGB_BLOCK):
+            return "FORMAT_ASTC_10x10_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_12x10_UNORM_BLOCK):
+            return "FORMAT_ASTC_12x10_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_12x10_SRGB_BLOCK):
+            return "FORMAT_ASTC_12x10_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_12x12_UNORM_BLOCK):
+            return "FORMAT_ASTC_12x12_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_12x12_SRGB_BLOCK):
+            return "FORMAT_ASTC_12x12_SRGB_BLOCK";
+        case (VK_FORMAT_G8B8G8R8_422_UNORM):
+            return "FORMAT_G8B8G8R8_422_UNORM";
+        case (VK_FORMAT_B8G8R8G8_422_UNORM):
+            return "FORMAT_B8G8R8G8_422_UNORM";
+        case (VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM):
+            return "FORMAT_G8_B8_R8_3PLANE_420_UNORM";
+        case (VK_FORMAT_G8_B8R8_2PLANE_420_UNORM):
+            return "FORMAT_G8_B8R8_2PLANE_420_UNORM";
+        case (VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM):
+            return "FORMAT_G8_B8_R8_3PLANE_422_UNORM";
+        case (VK_FORMAT_G8_B8R8_2PLANE_422_UNORM):
+            return "FORMAT_G8_B8R8_2PLANE_422_UNORM";
+        case (VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM):
+            return "FORMAT_G8_B8_R8_3PLANE_444_UNORM";
+        case (VK_FORMAT_R10X6_UNORM_PACK16):
+            return "FORMAT_R10X6_UNORM_PACK16";
+        case (VK_FORMAT_R10X6G10X6_UNORM_2PACK16):
+            return "FORMAT_R10X6G10X6_UNORM_2PACK16";
+        case (VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16):
+            return "FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16";
+        case (VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16):
+            return "FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16";
+        case (VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16):
+            return "FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16";
+        case (VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16):
+            return "FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16";
+        case (VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16):
+            return "FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16";
+        case (VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16):
+            return "FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16";
+        case (VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16):
+            return "FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16";
+        case (VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16):
+            return "FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16";
+        case (VK_FORMAT_R12X4_UNORM_PACK16):
+            return "FORMAT_R12X4_UNORM_PACK16";
+        case (VK_FORMAT_R12X4G12X4_UNORM_2PACK16):
+            return "FORMAT_R12X4G12X4_UNORM_2PACK16";
+        case (VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16):
+            return "FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16";
+        case (VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16):
+            return "FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16";
+        case (VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16):
+            return "FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16";
+        case (VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16):
+            return "FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16";
+        case (VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16):
+            return "FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16";
+        case (VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16):
+            return "FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16";
+        case (VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16):
+            return "FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16";
+        case (VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16):
+            return "FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16";
+        case (VK_FORMAT_G16B16G16R16_422_UNORM):
+            return "FORMAT_G16B16G16R16_422_UNORM";
+        case (VK_FORMAT_B16G16R16G16_422_UNORM):
+            return "FORMAT_B16G16R16G16_422_UNORM";
+        case (VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM):
+            return "FORMAT_G16_B16_R16_3PLANE_420_UNORM";
+        case (VK_FORMAT_G16_B16R16_2PLANE_420_UNORM):
+            return "FORMAT_G16_B16R16_2PLANE_420_UNORM";
+        case (VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM):
+            return "FORMAT_G16_B16_R16_3PLANE_422_UNORM";
+        case (VK_FORMAT_G16_B16R16_2PLANE_422_UNORM):
+            return "FORMAT_G16_B16R16_2PLANE_422_UNORM";
+        case (VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM):
+            return "FORMAT_G16_B16_R16_3PLANE_444_UNORM";
+        case (VK_FORMAT_G8_B8R8_2PLANE_444_UNORM):
+            return "FORMAT_G8_B8R8_2PLANE_444_UNORM";
+        case (VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16):
+            return "FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16";
+        case (VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16):
+            return "FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16";
+        case (VK_FORMAT_G16_B16R16_2PLANE_444_UNORM):
+            return "FORMAT_G16_B16R16_2PLANE_444_UNORM";
+        case (VK_FORMAT_A4R4G4B4_UNORM_PACK16):
+            return "FORMAT_A4R4G4B4_UNORM_PACK16";
+        case (VK_FORMAT_A4B4G4R4_UNORM_PACK16):
+            return "FORMAT_A4B4G4R4_UNORM_PACK16";
+        case (VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_4x4_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_5x4_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_5x5_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_6x5_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_6x6_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_8x5_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_8x6_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_8x8_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_10x5_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_10x6_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_10x8_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_10x10_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_12x10_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_12x12_SFLOAT_BLOCK";
+        case (VK_FORMAT_A1B5G5R5_UNORM_PACK16):
+            return "FORMAT_A1B5G5R5_UNORM_PACK16";
+        case (VK_FORMAT_A8_UNORM):
+            return "FORMAT_A8_UNORM";
+        case (VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG):
+            return "FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG):
+            return "FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG):
+            return "FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG):
+            return "FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG):
+            return "FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG):
+            return "FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG):
+            return "FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG):
+            return "FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG";
+        case (VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_R8_BOOL_ARM):
+            return "FORMAT_R8_BOOL_ARM";
+        case (VK_FORMAT_R16_SFLOAT_FPENCODING_BFLOAT16_ARM):
+            return "FORMAT_R16_SFLOAT_FPENCODING_BFLOAT16_ARM";
+        case (VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E4M3_ARM):
+            return "FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E4M3_ARM";
+        case (VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E5M2_ARM):
+            return "FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E5M2_ARM";
+        case (VK_FORMAT_R16G16_SFIXED5_NV):
+            return "FORMAT_R16G16_SFIXED5_NV";
+        case (VK_FORMAT_R10X6_UINT_PACK16_ARM):
+            return "FORMAT_R10X6_UINT_PACK16_ARM";
+        case (VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM):
+            return "FORMAT_R10X6G10X6_UINT_2PACK16_ARM";
+        case (VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM):
+            return "FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM";
+        case (VK_FORMAT_R12X4_UINT_PACK16_ARM):
+            return "FORMAT_R12X4_UINT_PACK16_ARM";
+        case (VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM):
+            return "FORMAT_R12X4G12X4_UINT_2PACK16_ARM";
+        case (VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM):
+            return "FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM";
+        case (VK_FORMAT_R14X2_UINT_PACK16_ARM):
+            return "FORMAT_R14X2_UINT_PACK16_ARM";
+        case (VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM):
+            return "FORMAT_R14X2G14X2_UINT_2PACK16_ARM";
+        case (VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM):
+            return "FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM";
+        case (VK_FORMAT_R14X2_UNORM_PACK16_ARM):
+            return "FORMAT_R14X2_UNORM_PACK16_ARM";
+        case (VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM):
+            return "FORMAT_R14X2G14X2_UNORM_2PACK16_ARM";
+        case (VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM):
+            return "FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM";
+        case (VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM):
+            return "FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM";
+        case (VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM):
+            return "FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM";
+        default:
+            return std::string("UNKNOWN_VkFormat_value") + std::to_string(value);
+    }
+}
+void DumpVkFormat(Printer &p, std::string name, VkFormat value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkFormatString(value));
+    else
+        p.PrintKeyString(name, VkFormatString(value));
+}
+std::string VkImageLayoutString(VkImageLayout value) {
+    switch (value) {
+        case (VK_IMAGE_LAYOUT_UNDEFINED):
+            return "IMAGE_LAYOUT_UNDEFINED";
+        case (VK_IMAGE_LAYOUT_GENERAL):
+            return "IMAGE_LAYOUT_GENERAL";
+        case (VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL):
+            return "IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL):
+            return "IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL):
+            return "IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL):
+            return "IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL):
+            return "IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL):
+            return "IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_PREINITIALIZED):
+            return "IMAGE_LAYOUT_PREINITIALIZED";
+        case (VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL):
+            return "IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL):
+            return "IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL):
+            return "IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL):
+            return "IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL):
+            return "IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL):
+            return "IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL):
+            return "IMAGE_LAYOUT_READ_ONLY_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL):
+            return "IMAGE_LAYOUT_ATTACHMENT_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ):
+            return "IMAGE_LAYOUT_RENDERING_LOCAL_READ";
+        case (VK_IMAGE_LAYOUT_PRESENT_SRC_KHR):
+            return "IMAGE_LAYOUT_PRESENT_SRC_KHR";
+        case (VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR):
+            return "IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR";
+        case (VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR):
+            return "IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR";
+        case (VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR):
+            return "IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR";
+        case (VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR):
+            return "IMAGE_LAYOUT_SHARED_PRESENT_KHR";
+        case (VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT):
+            return "IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT";
+        case (VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR):
+            return "IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR";
+        case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR):
+            return "IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR";
+        case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR):
+            return "IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR";
+        case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR):
+            return "IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR";
+        case (VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT):
+            return "IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT";
+        case (VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM):
+            return "IMAGE_LAYOUT_TENSOR_ALIASING_ARM";
+        case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR):
+            return "IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR";
+        case (VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT):
+            return "IMAGE_LAYOUT_ZERO_INITIALIZED_EXT";
+        default:
+            return std::string("UNKNOWN_VkImageLayout_value") + std::to_string(value);
+    }
+}
+void DumpVkImageLayout(Printer &p, std::string name, VkImageLayout value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkImageLayoutString(value));
+    else
+        p.PrintKeyString(name, VkImageLayoutString(value));
+}
+std::string VkImageTilingString(VkImageTiling value) {
+    switch (value) {
+        case (VK_IMAGE_TILING_OPTIMAL):
+            return "IMAGE_TILING_OPTIMAL";
+        case (VK_IMAGE_TILING_LINEAR):
+            return "IMAGE_TILING_LINEAR";
+        case (VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT):
+            return "IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT";
+        default:
+            return std::string("UNKNOWN_VkImageTiling_value") + std::to_string(value);
+    }
+}
+void DumpVkImageTiling(Printer &p, std::string name, VkImageTiling value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkImageTilingString(value));
+    else
+        p.PrintKeyString(name, VkImageTilingString(value));
+}
+std::string VkImageTypeString(VkImageType value) {
+    switch (value) {
+        case (VK_IMAGE_TYPE_1D):
+            return "IMAGE_TYPE_1D";
+        case (VK_IMAGE_TYPE_2D):
+            return "IMAGE_TYPE_2D";
+        case (VK_IMAGE_TYPE_3D):
+            return "IMAGE_TYPE_3D";
+        default:
+            return std::string("UNKNOWN_VkImageType_value") + std::to_string(value);
+    }
+}
+void DumpVkImageType(Printer &p, std::string name, VkImageType value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkImageTypeString(value));
+    else
+        p.PrintKeyString(name, VkImageTypeString(value));
+}
+std::string VkPhysicalDeviceLayeredApiKHRString(VkPhysicalDeviceLayeredApiKHR value) {
+    switch (value) {
+        case (VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR):
+            return "PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR";
+        case (VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR):
+            return "PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR";
+        case (VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR):
+            return "PHYSICAL_DEVICE_LAYERED_API_METAL_KHR";
+        case (VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR):
+            return "PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR";
+        case (VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR):
+            return "PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR";
+        default:
+            return std::string("UNKNOWN_VkPhysicalDeviceLayeredApiKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkPhysicalDeviceLayeredApiKHR(Printer &p, std::string name, VkPhysicalDeviceLayeredApiKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkPhysicalDeviceLayeredApiKHRString(value));
+    else
+        p.PrintKeyString(name, VkPhysicalDeviceLayeredApiKHRString(value));
+}
+std::string VkPhysicalDeviceTypeString(VkPhysicalDeviceType value) {
+    switch (value) {
+        case (VK_PHYSICAL_DEVICE_TYPE_OTHER):
+            return "PHYSICAL_DEVICE_TYPE_OTHER";
+        case (VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU):
+            return "PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU";
+        case (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU):
+            return "PHYSICAL_DEVICE_TYPE_DISCRETE_GPU";
+        case (VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU):
+            return "PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU";
+        case (VK_PHYSICAL_DEVICE_TYPE_CPU):
+            return "PHYSICAL_DEVICE_TYPE_CPU";
+        default:
+            return std::string("UNKNOWN_VkPhysicalDeviceType_value") + std::to_string(value);
+    }
+}
+void DumpVkPhysicalDeviceType(Printer &p, std::string name, VkPhysicalDeviceType value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkPhysicalDeviceTypeString(value));
+    else
+        p.PrintKeyString(name, VkPhysicalDeviceTypeString(value));
+}
+std::string VkPipelineRobustnessBufferBehaviorString(VkPipelineRobustnessBufferBehavior value) {
+    switch (value) {
+        case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT):
+            return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT";
+        case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED):
+            return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED";
+        case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS):
+            return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS";
+        case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2):
+            return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2";
+        default:
+            return std::string("UNKNOWN_VkPipelineRobustnessBufferBehavior_value") + std::to_string(value);
+    }
+}
+void DumpVkPipelineRobustnessBufferBehavior(Printer &p, std::string name, VkPipelineRobustnessBufferBehavior value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkPipelineRobustnessBufferBehaviorString(value));
+    else
+        p.PrintKeyString(name, VkPipelineRobustnessBufferBehaviorString(value));
+}
+std::string VkPipelineRobustnessImageBehaviorString(VkPipelineRobustnessImageBehavior value) {
+    switch (value) {
+        case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT):
+            return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT";
+        case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED):
+            return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED";
+        case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS):
+            return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS";
+        case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2):
+            return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2";
+        default:
+            return std::string("UNKNOWN_VkPipelineRobustnessImageBehavior_value") + std::to_string(value);
+    }
+}
+void DumpVkPipelineRobustnessImageBehavior(Printer &p, std::string name, VkPipelineRobustnessImageBehavior value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkPipelineRobustnessImageBehaviorString(value));
+    else
+        p.PrintKeyString(name, VkPipelineRobustnessImageBehaviorString(value));
+}
+std::string VkPointClippingBehaviorString(VkPointClippingBehavior value) {
+    switch (value) {
+        case (VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES):
+            return "POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES";
+        case (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY):
+            return "POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY";
+        default:
+            return std::string("UNKNOWN_VkPointClippingBehavior_value") + std::to_string(value);
+    }
+}
+void DumpVkPointClippingBehavior(Printer &p, std::string name, VkPointClippingBehavior value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkPointClippingBehaviorString(value));
+    else
+        p.PrintKeyString(name, VkPointClippingBehaviorString(value));
+}
+std::string VkPresentModeKHRString(VkPresentModeKHR value) {
+    switch (value) {
+        case (VK_PRESENT_MODE_IMMEDIATE_KHR):
+            return "PRESENT_MODE_IMMEDIATE_KHR";
+        case (VK_PRESENT_MODE_MAILBOX_KHR):
+            return "PRESENT_MODE_MAILBOX_KHR";
+        case (VK_PRESENT_MODE_FIFO_KHR):
+            return "PRESENT_MODE_FIFO_KHR";
+        case (VK_PRESENT_MODE_FIFO_RELAXED_KHR):
+            return "PRESENT_MODE_FIFO_RELAXED_KHR";
+        case (VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR):
+            return "PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR";
+        case (VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR):
+            return "PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR";
+        case (VK_PRESENT_MODE_FIFO_LATEST_READY_KHR):
+            return "PRESENT_MODE_FIFO_LATEST_READY_KHR";
+        default:
+            return std::string("UNKNOWN_VkPresentModeKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkPresentModeKHR(Printer &p, std::string name, VkPresentModeKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkPresentModeKHRString(value));
+    else
+        p.PrintKeyString(name, VkPresentModeKHRString(value));
+}
+std::string VkQueueGlobalPriorityString(VkQueueGlobalPriority value) {
+    switch (value) {
+        case (VK_QUEUE_GLOBAL_PRIORITY_LOW):
+            return "QUEUE_GLOBAL_PRIORITY_LOW";
+        case (VK_QUEUE_GLOBAL_PRIORITY_MEDIUM):
+            return "QUEUE_GLOBAL_PRIORITY_MEDIUM";
+        case (VK_QUEUE_GLOBAL_PRIORITY_HIGH):
+            return "QUEUE_GLOBAL_PRIORITY_HIGH";
+        case (VK_QUEUE_GLOBAL_PRIORITY_REALTIME):
+            return "QUEUE_GLOBAL_PRIORITY_REALTIME";
+        default:
+            return std::string("UNKNOWN_VkQueueGlobalPriority_value") + std::to_string(value);
+    }
+}
+void DumpVkQueueGlobalPriority(Printer &p, std::string name, VkQueueGlobalPriority value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkQueueGlobalPriorityString(value));
+    else
+        p.PrintKeyString(name, VkQueueGlobalPriorityString(value));
+}
+std::string VkRayTracingInvocationReorderModeEXTString(VkRayTracingInvocationReorderModeEXT value) {
+    switch (value) {
+        case (VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT):
+            return "RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT";
+        case (VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT):
+            return "RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT";
+        default:
+            return std::string("UNKNOWN_VkRayTracingInvocationReorderModeEXT_value") + std::to_string(value);
+    }
+}
+void DumpVkRayTracingInvocationReorderModeEXT(Printer &p, std::string name, VkRayTracingInvocationReorderModeEXT value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkRayTracingInvocationReorderModeEXTString(value));
+    else
+        p.PrintKeyString(name, VkRayTracingInvocationReorderModeEXTString(value));
+}
+std::string VkResultString(VkResult value) {
+    switch (value) {
+        case (VK_SUCCESS):
+            return "SUCCESS";
+        case (VK_NOT_READY):
+            return "NOT_READY";
+        case (VK_TIMEOUT):
+            return "TIMEOUT";
+        case (VK_EVENT_SET):
+            return "EVENT_SET";
+        case (VK_EVENT_RESET):
+            return "EVENT_RESET";
+        case (VK_INCOMPLETE):
+            return "INCOMPLETE";
+        case (VK_ERROR_OUT_OF_HOST_MEMORY):
+            return "ERROR_OUT_OF_HOST_MEMORY";
+        case (VK_ERROR_OUT_OF_DEVICE_MEMORY):
+            return "ERROR_OUT_OF_DEVICE_MEMORY";
+        case (VK_ERROR_INITIALIZATION_FAILED):
+            return "ERROR_INITIALIZATION_FAILED";
+        case (VK_ERROR_DEVICE_LOST):
+            return "ERROR_DEVICE_LOST";
+        case (VK_ERROR_MEMORY_MAP_FAILED):
+            return "ERROR_MEMORY_MAP_FAILED";
+        case (VK_ERROR_LAYER_NOT_PRESENT):
+            return "ERROR_LAYER_NOT_PRESENT";
+        case (VK_ERROR_EXTENSION_NOT_PRESENT):
+            return "ERROR_EXTENSION_NOT_PRESENT";
+        case (VK_ERROR_FEATURE_NOT_PRESENT):
+            return "ERROR_FEATURE_NOT_PRESENT";
+        case (VK_ERROR_INCOMPATIBLE_DRIVER):
+            return "ERROR_INCOMPATIBLE_DRIVER";
+        case (VK_ERROR_TOO_MANY_OBJECTS):
+            return "ERROR_TOO_MANY_OBJECTS";
+        case (VK_ERROR_FORMAT_NOT_SUPPORTED):
+            return "ERROR_FORMAT_NOT_SUPPORTED";
+        case (VK_ERROR_FRAGMENTED_POOL):
+            return "ERROR_FRAGMENTED_POOL";
+        case (VK_ERROR_UNKNOWN):
+            return "ERROR_UNKNOWN";
+        case (VK_ERROR_VALIDATION_FAILED):
+            return "ERROR_VALIDATION_FAILED";
+        case (VK_ERROR_OUT_OF_POOL_MEMORY):
+            return "ERROR_OUT_OF_POOL_MEMORY";
+        case (VK_ERROR_INVALID_EXTERNAL_HANDLE):
+            return "ERROR_INVALID_EXTERNAL_HANDLE";
+        case (VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS):
+            return "ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS";
+        case (VK_ERROR_FRAGMENTATION):
+            return "ERROR_FRAGMENTATION";
+        case (VK_PIPELINE_COMPILE_REQUIRED):
+            return "PIPELINE_COMPILE_REQUIRED";
+        case (VK_ERROR_NOT_PERMITTED):
+            return "ERROR_NOT_PERMITTED";
+        case (VK_ERROR_SURFACE_LOST_KHR):
+            return "ERROR_SURFACE_LOST_KHR";
+        case (VK_ERROR_NATIVE_WINDOW_IN_USE_KHR):
+            return "ERROR_NATIVE_WINDOW_IN_USE_KHR";
+        case (VK_SUBOPTIMAL_KHR):
+            return "SUBOPTIMAL_KHR";
+        case (VK_ERROR_OUT_OF_DATE_KHR):
+            return "ERROR_OUT_OF_DATE_KHR";
+        case (VK_ERROR_INCOMPATIBLE_DISPLAY_KHR):
+            return "ERROR_INCOMPATIBLE_DISPLAY_KHR";
+        case (VK_ERROR_INVALID_SHADER_NV):
+            return "ERROR_INVALID_SHADER_NV";
+        case (VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR):
+            return "ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR";
+        case (VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR):
+            return "ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR";
+        case (VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR):
+            return "ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR";
+        case (VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR):
+            return "ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR";
+        case (VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR):
+            return "ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR";
+        case (VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR):
+            return "ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR";
+        case (VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT):
+            return "ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT";
+        case (VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT):
+            return "ERROR_PRESENT_TIMING_QUEUE_FULL_EXT";
+        case (VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT):
+            return "ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
+        case (VK_THREAD_IDLE_KHR):
+            return "THREAD_IDLE_KHR";
+        case (VK_THREAD_DONE_KHR):
+            return "THREAD_DONE_KHR";
+        case (VK_OPERATION_DEFERRED_KHR):
+            return "OPERATION_DEFERRED_KHR";
+        case (VK_OPERATION_NOT_DEFERRED_KHR):
+            return "OPERATION_NOT_DEFERRED_KHR";
+        case (VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR):
+            return "ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR";
+        case (VK_ERROR_COMPRESSION_EXHAUSTED_EXT):
+            return "ERROR_COMPRESSION_EXHAUSTED_EXT";
+        case (VK_INCOMPATIBLE_SHADER_BINARY_EXT):
+            return "INCOMPATIBLE_SHADER_BINARY_EXT";
+        case (VK_PIPELINE_BINARY_MISSING_KHR):
+            return "PIPELINE_BINARY_MISSING_KHR";
+        case (VK_ERROR_NOT_ENOUGH_SPACE_KHR):
+            return "ERROR_NOT_ENOUGH_SPACE_KHR";
+        default:
+            return std::string("UNKNOWN_VkResult_value") + std::to_string(value);
+    }
+}
+void DumpVkResult(Printer &p, std::string name, VkResult value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkResultString(value));
+    else
+        p.PrintKeyString(name, VkResultString(value));
+}
+std::string VkScopeKHRString(VkScopeKHR value) {
+    switch (value) {
+        case (VK_SCOPE_DEVICE_KHR):
+            return "SCOPE_DEVICE_KHR";
+        case (VK_SCOPE_WORKGROUP_KHR):
+            return "SCOPE_WORKGROUP_KHR";
+        case (VK_SCOPE_SUBGROUP_KHR):
+            return "SCOPE_SUBGROUP_KHR";
+        case (VK_SCOPE_QUEUE_FAMILY_KHR):
+            return "SCOPE_QUEUE_FAMILY_KHR";
+        default:
+            return std::string("UNKNOWN_VkScopeKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkScopeKHR(Printer &p, std::string name, VkScopeKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkScopeKHRString(value));
+    else
+        p.PrintKeyString(name, VkScopeKHRString(value));
+}
+std::string VkShaderFloatControlsIndependenceString(VkShaderFloatControlsIndependence value) {
+    switch (value) {
+        case (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY):
+            return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY";
+        case (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL):
+            return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL";
+        case (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE):
+            return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE";
+        default:
+            return std::string("UNKNOWN_VkShaderFloatControlsIndependence_value") + std::to_string(value);
+    }
+}
+void DumpVkShaderFloatControlsIndependence(Printer &p, std::string name, VkShaderFloatControlsIndependence value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkShaderFloatControlsIndependenceString(value));
+    else
+        p.PrintKeyString(name, VkShaderFloatControlsIndependenceString(value));
+}
+std::string VkTimeDomainKHRString(VkTimeDomainKHR value) {
+    switch (value) {
+        case (VK_TIME_DOMAIN_DEVICE_KHR):
+            return "TIME_DOMAIN_DEVICE_KHR";
+        case (VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR):
+            return "TIME_DOMAIN_CLOCK_MONOTONIC_KHR";
+        case (VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR):
+            return "TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR";
+        case (VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR):
+            return "TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR";
+        case (VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT):
+            return "TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT";
+        case (VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT):
+            return "TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT";
+        default:
+            return std::string("UNKNOWN_VkTimeDomainKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkTimeDomainKHR(Printer &p, std::string name, VkTimeDomainKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkTimeDomainKHRString(value));
+    else
+        p.PrintKeyString(name, VkTimeDomainKHRString(value));
+}
+std::string VkVideoEncodeTuningModeKHRString(VkVideoEncodeTuningModeKHR value) {
+    switch (value) {
+        case (VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR):
+            return "VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR";
+        case (VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR):
+            return "VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR";
+        case (VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR):
+            return "VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR";
+        case (VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR):
+            return "VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR";
+        case (VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR):
+            return "VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR";
+        default:
+            return std::string("UNKNOWN_VkVideoEncodeTuningModeKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkVideoEncodeTuningModeKHR(Printer &p, std::string name, VkVideoEncodeTuningModeKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkVideoEncodeTuningModeKHRString(value));
+    else
+        p.PrintKeyString(name, VkVideoEncodeTuningModeKHRString(value));
+}
+std::vector<const char *> VkCompositeAlphaFlagBitsKHRGetStrings(VkCompositeAlphaFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR & value) strings.push_back("COMPOSITE_ALPHA_OPAQUE_BIT_KHR");
+    if (VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR & value) strings.push_back("COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR");
+    if (VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR & value) strings.push_back("COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR");
+    if (VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR & value) strings.push_back("COMPOSITE_ALPHA_INHERIT_BIT_KHR");
+    return strings;
+}
+void DumpVkCompositeAlphaFlagsKHR(Printer &p, std::string name, VkCompositeAlphaFlagsKHR value) {
+    if (static_cast<VkCompositeAlphaFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkCompositeAlphaFlagBitsKHRGetStrings(static_cast<VkCompositeAlphaFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkCompositeAlphaFlagBitsKHR(Printer &p, std::string name, VkCompositeAlphaFlagBitsKHR value) {
+    auto strings = VkCompositeAlphaFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkDeviceGroupPresentModeFlagBitsKHRGetStrings(VkDeviceGroupPresentModeFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR");
+    if (VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR");
+    if (VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR");
+    if (VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR & value)
+        strings.push_back("DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR");
+    return strings;
+}
+void DumpVkDeviceGroupPresentModeFlagsKHR(Printer &p, std::string name, VkDeviceGroupPresentModeFlagsKHR value) {
+    if (static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkDeviceGroupPresentModeFlagBitsKHRGetStrings(static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkDeviceGroupPresentModeFlagBitsKHR(Printer &p, std::string name, VkDeviceGroupPresentModeFlagBitsKHR value) {
+    auto strings = VkDeviceGroupPresentModeFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkDisplayPlaneAlphaFlagBitsKHRGetStrings(VkDisplayPlaneAlphaFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR & value) strings.push_back("DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR");
+    if (VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR & value) strings.push_back("DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR");
+    if (VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR & value) strings.push_back("DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR");
+    if (VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR & value)
+        strings.push_back("DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR");
+    return strings;
+}
+void DumpVkDisplayPlaneAlphaFlagsKHR(Printer &p, std::string name, VkDisplayPlaneAlphaFlagsKHR value) {
+    if (static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkDisplayPlaneAlphaFlagBitsKHRGetStrings(static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkDisplayPlaneAlphaFlagBitsKHR(Printer &p, std::string name, VkDisplayPlaneAlphaFlagBitsKHR value) {
+    auto strings = VkDisplayPlaneAlphaFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkFormatFeatureFlagBitsGetStrings(VkFormatFeatureFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_BIT");
+    if (VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_STORAGE_IMAGE_BIT");
+    if (VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT & value) strings.push_back("FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT");
+    if (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT");
+    if (VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT");
+    if (VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT & value)
+        strings.push_back("FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT");
+    if (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_VERTEX_BUFFER_BIT");
+    if (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT & value) strings.push_back("FORMAT_FEATURE_COLOR_ATTACHMENT_BIT");
+    if (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT & value) strings.push_back("FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT");
+    if (VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT & value) strings.push_back("FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT");
+    if (VK_FORMAT_FEATURE_BLIT_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_BLIT_SRC_BIT");
+    if (VK_FORMAT_FEATURE_BLIT_DST_BIT & value) strings.push_back("FORMAT_FEATURE_BLIT_DST_BIT");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT");
+    if (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_TRANSFER_SRC_BIT");
+    if (VK_FORMAT_FEATURE_TRANSFER_DST_BIT & value) strings.push_back("FORMAT_FEATURE_TRANSFER_DST_BIT");
+    if (VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT");
+    if (VK_FORMAT_FEATURE_DISJOINT_BIT & value) strings.push_back("FORMAT_FEATURE_DISJOINT_BIT");
+    if (VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT");
+    if (VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR");
+    if (VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR");
+    if (VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT");
+    if (VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT & value) strings.push_back("FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT");
+    if (VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR");
+    if (VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR");
+    if (VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR");
+    return strings;
+}
+void DumpVkFormatFeatureFlags(Printer &p, std::string name, VkFormatFeatureFlags value) {
+    if (static_cast<VkFormatFeatureFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkFormatFeatureFlagBitsGetStrings(static_cast<VkFormatFeatureFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkFormatFeatureFlagBits(Printer &p, std::string name, VkFormatFeatureFlagBits value) {
+    auto strings = VkFormatFeatureFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkFormatFeatureFlagBits2GetStrings(VkFormatFeatureFlagBits2 value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT");
+    if (VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_2_STORAGE_IMAGE_BIT");
+    if (VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT & value) strings.push_back("FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT");
+    if (VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT");
+    if (VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT");
+    if (VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT");
+    if (VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_2_VERTEX_BUFFER_BIT");
+    if (VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT & value) strings.push_back("FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT");
+    if (VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT & value) strings.push_back("FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT");
+    if (VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT");
+    if (VK_FORMAT_FEATURE_2_BLIT_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_2_BLIT_SRC_BIT");
+    if (VK_FORMAT_FEATURE_2_BLIT_DST_BIT & value) strings.push_back("FORMAT_FEATURE_2_BLIT_DST_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT");
+    if (VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_2_TRANSFER_SRC_BIT");
+    if (VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT & value) strings.push_back("FORMAT_FEATURE_2_TRANSFER_DST_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT");
+    if (VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT");
+    if (VK_FORMAT_FEATURE_2_DISJOINT_BIT & value) strings.push_back("FORMAT_FEATURE_2_DISJOINT_BIT");
+    if (VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT");
+    if (VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT");
+    if (VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT");
+    if (VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT & value) strings.push_back("FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT");
+    if (VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT & value)
+        strings.push_back("FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT");
+    if (VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV & value)
+        strings.push_back("FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV");
+    if (VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV & value)
+        strings.push_back("FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV");
+    if (VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM & value) strings.push_back("FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM");
+    if (VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM & value)
+        strings.push_back("FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM");
+    if (VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM & value) strings.push_back("FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM");
+    if (VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM & value) strings.push_back("FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM");
+    if (VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM & value) strings.push_back("FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM");
+    if (VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM & value)
+        strings.push_back("FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM");
+    if (VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV & value) strings.push_back("FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV");
+    if (VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV & value) strings.push_back("FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV");
+    if (VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV & value) strings.push_back("FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV");
+    if (VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM & value) strings.push_back("FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM");
+    if (VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR");
+    return strings;
+}
+void DumpVkFormatFeatureFlags2(Printer &p, std::string name, VkFormatFeatureFlags2 value) {
+    if (static_cast<VkFormatFeatureFlagBits2>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkFormatFeatureFlagBits2GetStrings(static_cast<VkFormatFeatureFlagBits2>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkFormatFeatureFlagBits2(Printer &p, std::string name, VkFormatFeatureFlagBits2 value) {
+    auto strings = VkFormatFeatureFlagBits2GetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkImageCreateFlagBitsGetStrings(VkImageCreateFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_IMAGE_CREATE_SPARSE_BINDING_BIT & value) strings.push_back("IMAGE_CREATE_SPARSE_BINDING_BIT");
+    if (VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT & value) strings.push_back("IMAGE_CREATE_SPARSE_RESIDENCY_BIT");
+    if (VK_IMAGE_CREATE_SPARSE_ALIASED_BIT & value) strings.push_back("IMAGE_CREATE_SPARSE_ALIASED_BIT");
+    if (VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT & value) strings.push_back("IMAGE_CREATE_MUTABLE_FORMAT_BIT");
+    if (VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT & value) strings.push_back("IMAGE_CREATE_CUBE_COMPATIBLE_BIT");
+    if (VK_IMAGE_CREATE_ALIAS_BIT & value) strings.push_back("IMAGE_CREATE_ALIAS_BIT");
+    if (VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT & value) strings.push_back("IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT");
+    if (VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT & value) strings.push_back("IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT");
+    if (VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT & value) strings.push_back("IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT");
+    if (VK_IMAGE_CREATE_EXTENDED_USAGE_BIT & value) strings.push_back("IMAGE_CREATE_EXTENDED_USAGE_BIT");
+    if (VK_IMAGE_CREATE_PROTECTED_BIT & value) strings.push_back("IMAGE_CREATE_PROTECTED_BIT");
+    if (VK_IMAGE_CREATE_DISJOINT_BIT & value) strings.push_back("IMAGE_CREATE_DISJOINT_BIT");
+    if (VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV & value) strings.push_back("IMAGE_CREATE_CORNER_SAMPLED_BIT_NV");
+    if (VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT & value)
+        strings.push_back("IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT");
+    if (VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT & value)
+        strings.push_back("IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT");
+    if (VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT & value) strings.push_back("IMAGE_CREATE_SUBSAMPLED_BIT_EXT");
+    if (VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT & value)
+        strings.push_back("IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT");
+    if (VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT & value) strings.push_back("IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT");
+    if (VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR & value)
+        strings.push_back("IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR");
+    if (VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT & value)
+        strings.push_back("IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT");
+    return strings;
+}
+void DumpVkImageCreateFlags(Printer &p, std::string name, VkImageCreateFlags value) {
+    if (static_cast<VkImageCreateFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkImageCreateFlagBitsGetStrings(static_cast<VkImageCreateFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkImageCreateFlagBits(Printer &p, std::string name, VkImageCreateFlagBits value) {
+    auto strings = VkImageCreateFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkImageUsageFlagBitsGetStrings(VkImageUsageFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_IMAGE_USAGE_TRANSFER_SRC_BIT & value) strings.push_back("IMAGE_USAGE_TRANSFER_SRC_BIT");
+    if (VK_IMAGE_USAGE_TRANSFER_DST_BIT & value) strings.push_back("IMAGE_USAGE_TRANSFER_DST_BIT");
+    if (VK_IMAGE_USAGE_SAMPLED_BIT & value) strings.push_back("IMAGE_USAGE_SAMPLED_BIT");
+    if (VK_IMAGE_USAGE_STORAGE_BIT & value) strings.push_back("IMAGE_USAGE_STORAGE_BIT");
+    if (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT & value) strings.push_back("IMAGE_USAGE_COLOR_ATTACHMENT_BIT");
+    if (VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT & value) strings.push_back("IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT");
+    if (VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT & value) strings.push_back("IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT");
+    if (VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT & value) strings.push_back("IMAGE_USAGE_INPUT_ATTACHMENT_BIT");
+    if (VK_IMAGE_USAGE_HOST_TRANSFER_BIT & value) strings.push_back("IMAGE_USAGE_HOST_TRANSFER_BIT");
+    if (VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR");
+    if (VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR");
+    if (VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR");
+    if (VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT & value) strings.push_back("IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT");
+    if (VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR & value)
+        strings.push_back("IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR");
+    if (VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR");
+    if (VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR");
+    if (VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR");
+    if (VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT & value) strings.push_back("IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT");
+    if (VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI & value) strings.push_back("IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI");
+    if (VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM & value) strings.push_back("IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM");
+    if (VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM & value) strings.push_back("IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM");
+    if (VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM & value) strings.push_back("IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM");
+    if (VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM & value) strings.push_back("IMAGE_USAGE_TILE_MEMORY_BIT_QCOM");
+    if (VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR & value)
+        strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR");
+    if (VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR & value)
+        strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR");
+    return strings;
+}
+void DumpVkImageUsageFlags(Printer &p, std::string name, VkImageUsageFlags value) {
+    if (static_cast<VkImageUsageFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkImageUsageFlagBitsGetStrings(static_cast<VkImageUsageFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkImageUsageFlagBits(Printer &p, std::string name, VkImageUsageFlagBits value) {
+    auto strings = VkImageUsageFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkIndirectCommandsInputModeFlagBitsEXTGetStrings(VkIndirectCommandsInputModeFlagBitsEXT value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT & value)
+        strings.push_back("INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT");
+    if (VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT & value)
+        strings.push_back("INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT");
+    return strings;
+}
+void DumpVkIndirectCommandsInputModeFlagsEXT(Printer &p, std::string name, VkIndirectCommandsInputModeFlagsEXT value) {
+    if (static_cast<VkIndirectCommandsInputModeFlagBitsEXT>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkIndirectCommandsInputModeFlagBitsEXTGetStrings(static_cast<VkIndirectCommandsInputModeFlagBitsEXT>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkIndirectCommandsInputModeFlagBitsEXT(Printer &p, std::string name, VkIndirectCommandsInputModeFlagBitsEXT value) {
+    auto strings = VkIndirectCommandsInputModeFlagBitsEXTGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkMemoryDecompressionMethodFlagBitsEXTGetStrings(VkMemoryDecompressionMethodFlagBitsEXT value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT & value)
+        strings.push_back("MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT");
+    return strings;
+}
+void DumpVkMemoryDecompressionMethodFlagsEXT(Printer &p, std::string name, VkMemoryDecompressionMethodFlagsEXT value) {
+    if (static_cast<VkMemoryDecompressionMethodFlagBitsEXT>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkMemoryDecompressionMethodFlagBitsEXTGetStrings(static_cast<VkMemoryDecompressionMethodFlagBitsEXT>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkMemoryDecompressionMethodFlagBitsEXT(Printer &p, std::string name, VkMemoryDecompressionMethodFlagBitsEXT value) {
+    auto strings = VkMemoryDecompressionMethodFlagBitsEXTGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkMemoryHeapFlagBitsGetStrings(VkMemoryHeapFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_MEMORY_HEAP_DEVICE_LOCAL_BIT & value) strings.push_back("MEMORY_HEAP_DEVICE_LOCAL_BIT");
+    if (VK_MEMORY_HEAP_MULTI_INSTANCE_BIT & value) strings.push_back("MEMORY_HEAP_MULTI_INSTANCE_BIT");
+    if (VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM & value) strings.push_back("MEMORY_HEAP_TILE_MEMORY_BIT_QCOM");
+    return strings;
+}
+void DumpVkMemoryHeapFlags(Printer &p, std::string name, VkMemoryHeapFlags value) {
+    if (static_cast<VkMemoryHeapFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkMemoryHeapFlagBitsGetStrings(static_cast<VkMemoryHeapFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkMemoryHeapFlagBits(Printer &p, std::string name, VkMemoryHeapFlagBits value) {
+    auto strings = VkMemoryHeapFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkMemoryPropertyFlagBitsGetStrings(VkMemoryPropertyFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT & value) strings.push_back("MEMORY_PROPERTY_DEVICE_LOCAL_BIT");
+    if (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT & value) strings.push_back("MEMORY_PROPERTY_HOST_VISIBLE_BIT");
+    if (VK_MEMORY_PROPERTY_HOST_COHERENT_BIT & value) strings.push_back("MEMORY_PROPERTY_HOST_COHERENT_BIT");
+    if (VK_MEMORY_PROPERTY_HOST_CACHED_BIT & value) strings.push_back("MEMORY_PROPERTY_HOST_CACHED_BIT");
+    if (VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT & value) strings.push_back("MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT");
+    if (VK_MEMORY_PROPERTY_PROTECTED_BIT & value) strings.push_back("MEMORY_PROPERTY_PROTECTED_BIT");
+    if (VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD & value) strings.push_back("MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD");
+    if (VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD & value) strings.push_back("MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD");
+    if (VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV & value) strings.push_back("MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV");
+    return strings;
+}
+void DumpVkMemoryPropertyFlags(Printer &p, std::string name, VkMemoryPropertyFlags value) {
+    if (static_cast<VkMemoryPropertyFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkMemoryPropertyFlagBitsGetStrings(static_cast<VkMemoryPropertyFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkMemoryPropertyFlagBits(Printer &p, std::string name, VkMemoryPropertyFlagBits value) {
+    auto strings = VkMemoryPropertyFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkPresentGravityFlagBitsKHRGetStrings(VkPresentGravityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_PRESENT_GRAVITY_MIN_BIT_KHR & value) strings.push_back("PRESENT_GRAVITY_MIN_BIT_KHR");
+    if (VK_PRESENT_GRAVITY_MAX_BIT_KHR & value) strings.push_back("PRESENT_GRAVITY_MAX_BIT_KHR");
+    if (VK_PRESENT_GRAVITY_CENTERED_BIT_KHR & value) strings.push_back("PRESENT_GRAVITY_CENTERED_BIT_KHR");
+    return strings;
+}
+void DumpVkPresentGravityFlagsKHR(Printer &p, std::string name, VkPresentGravityFlagsKHR value) {
+    if (static_cast<VkPresentGravityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkPresentGravityFlagBitsKHRGetStrings(static_cast<VkPresentGravityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkPresentGravityFlagBitsKHR(Printer &p, std::string name, VkPresentGravityFlagBitsKHR value) {
+    auto strings = VkPresentGravityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkPresentScalingFlagBitsKHRGetStrings(VkPresentScalingFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR & value) strings.push_back("PRESENT_SCALING_ONE_TO_ONE_BIT_KHR");
+    if (VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR & value) strings.push_back("PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR");
+    if (VK_PRESENT_SCALING_STRETCH_BIT_KHR & value) strings.push_back("PRESENT_SCALING_STRETCH_BIT_KHR");
+    return strings;
+}
+void DumpVkPresentScalingFlagsKHR(Printer &p, std::string name, VkPresentScalingFlagsKHR value) {
+    if (static_cast<VkPresentScalingFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkPresentScalingFlagBitsKHRGetStrings(static_cast<VkPresentScalingFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkPresentScalingFlagBitsKHR(Printer &p, std::string name, VkPresentScalingFlagBitsKHR value) {
+    auto strings = VkPresentScalingFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkPresentStageFlagBitsEXTGetStrings(VkPresentStageFlagBitsEXT value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT & value) strings.push_back("PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT");
+    if (VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT & value) strings.push_back("PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT");
+    if (VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT & value) strings.push_back("PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT");
+    if (VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT & value)
+        strings.push_back("PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT");
+    return strings;
+}
+void DumpVkPresentStageFlagsEXT(Printer &p, std::string name, VkPresentStageFlagsEXT value) {
+    if (static_cast<VkPresentStageFlagBitsEXT>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkPresentStageFlagBitsEXTGetStrings(static_cast<VkPresentStageFlagBitsEXT>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkPresentStageFlagBitsEXT(Printer &p, std::string name, VkPresentStageFlagBitsEXT value) {
+    auto strings = VkPresentStageFlagBitsEXTGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkQueueFlagBitsGetStrings(VkQueueFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_QUEUE_GRAPHICS_BIT & value) strings.push_back("QUEUE_GRAPHICS_BIT");
+    if (VK_QUEUE_COMPUTE_BIT & value) strings.push_back("QUEUE_COMPUTE_BIT");
+    if (VK_QUEUE_TRANSFER_BIT & value) strings.push_back("QUEUE_TRANSFER_BIT");
+    if (VK_QUEUE_SPARSE_BINDING_BIT & value) strings.push_back("QUEUE_SPARSE_BINDING_BIT");
+    if (VK_QUEUE_PROTECTED_BIT & value) strings.push_back("QUEUE_PROTECTED_BIT");
+    if (VK_QUEUE_VIDEO_DECODE_BIT_KHR & value) strings.push_back("QUEUE_VIDEO_DECODE_BIT_KHR");
+    if (VK_QUEUE_VIDEO_ENCODE_BIT_KHR & value) strings.push_back("QUEUE_VIDEO_ENCODE_BIT_KHR");
+    if (VK_QUEUE_OPTICAL_FLOW_BIT_NV & value) strings.push_back("QUEUE_OPTICAL_FLOW_BIT_NV");
+    if (VK_QUEUE_DATA_GRAPH_BIT_ARM & value) strings.push_back("QUEUE_DATA_GRAPH_BIT_ARM");
+    return strings;
+}
+void DumpVkQueueFlags(Printer &p, std::string name, VkQueueFlags value) {
+    if (static_cast<VkQueueFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkQueueFlagBitsGetStrings(static_cast<VkQueueFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkQueueFlagBits(Printer &p, std::string name, VkQueueFlagBits value) {
+    auto strings = VkQueueFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::string VkQueueFlagsString(VkQueueFlags value) {
+    std::string out;
+    bool is_first = true;
+    if (VK_QUEUE_GRAPHICS_BIT & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_GRAPHICS_BIT";
+    }
+    if (VK_QUEUE_COMPUTE_BIT & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_COMPUTE_BIT";
+    }
+    if (VK_QUEUE_TRANSFER_BIT & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_TRANSFER_BIT";
+    }
+    if (VK_QUEUE_SPARSE_BINDING_BIT & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_SPARSE_BINDING_BIT";
+    }
+    if (VK_QUEUE_PROTECTED_BIT & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_PROTECTED_BIT";
+    }
+    if (VK_QUEUE_VIDEO_DECODE_BIT_KHR & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_VIDEO_DECODE_BIT_KHR";
+    }
+    if (VK_QUEUE_VIDEO_ENCODE_BIT_KHR & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_VIDEO_ENCODE_BIT_KHR";
+    }
+    if (VK_QUEUE_OPTICAL_FLOW_BIT_NV & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_OPTICAL_FLOW_BIT_NV";
+    }
+    if (VK_QUEUE_DATA_GRAPH_BIT_ARM & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_DATA_GRAPH_BIT_ARM";
+    }
+    return out;
+}
+std::vector<const char *> VkResolveModeFlagBitsGetStrings(VkResolveModeFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("RESOLVE_MODE_NONE");
+        return strings;
+    }
+    if (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT & value) strings.push_back("RESOLVE_MODE_SAMPLE_ZERO_BIT");
+    if (VK_RESOLVE_MODE_AVERAGE_BIT & value) strings.push_back("RESOLVE_MODE_AVERAGE_BIT");
+    if (VK_RESOLVE_MODE_MIN_BIT & value) strings.push_back("RESOLVE_MODE_MIN_BIT");
+    if (VK_RESOLVE_MODE_MAX_BIT & value) strings.push_back("RESOLVE_MODE_MAX_BIT");
+    if (VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID & value)
+        strings.push_back("RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID");
+    if (VK_RESOLVE_MODE_CUSTOM_BIT_EXT & value) strings.push_back("RESOLVE_MODE_CUSTOM_BIT_EXT");
+    return strings;
+}
+void DumpVkResolveModeFlags(Printer &p, std::string name, VkResolveModeFlags value) {
+    if (static_cast<VkResolveModeFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkResolveModeFlagBitsGetStrings(static_cast<VkResolveModeFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkResolveModeFlagBits(Printer &p, std::string name, VkResolveModeFlagBits value) {
+    auto strings = VkResolveModeFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkSampleCountFlagBitsGetStrings(VkSampleCountFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_SAMPLE_COUNT_1_BIT & value) strings.push_back("SAMPLE_COUNT_1_BIT");
+    if (VK_SAMPLE_COUNT_2_BIT & value) strings.push_back("SAMPLE_COUNT_2_BIT");
+    if (VK_SAMPLE_COUNT_4_BIT & value) strings.push_back("SAMPLE_COUNT_4_BIT");
+    if (VK_SAMPLE_COUNT_8_BIT & value) strings.push_back("SAMPLE_COUNT_8_BIT");
+    if (VK_SAMPLE_COUNT_16_BIT & value) strings.push_back("SAMPLE_COUNT_16_BIT");
+    if (VK_SAMPLE_COUNT_32_BIT & value) strings.push_back("SAMPLE_COUNT_32_BIT");
+    if (VK_SAMPLE_COUNT_64_BIT & value) strings.push_back("SAMPLE_COUNT_64_BIT");
+    return strings;
+}
+void DumpVkSampleCountFlags(Printer &p, std::string name, VkSampleCountFlags value) {
+    if (static_cast<VkSampleCountFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkSampleCountFlagBitsGetStrings(static_cast<VkSampleCountFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkSampleCountFlagBits(Printer &p, std::string name, VkSampleCountFlagBits value) {
+    auto strings = VkSampleCountFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkShaderStageFlagBitsGetStrings(VkShaderStageFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_SHADER_STAGE_VERTEX_BIT & value) strings.push_back("SHADER_STAGE_VERTEX_BIT");
+    if (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT & value) strings.push_back("SHADER_STAGE_TESSELLATION_CONTROL_BIT");
+    if (VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT & value) strings.push_back("SHADER_STAGE_TESSELLATION_EVALUATION_BIT");
+    if (VK_SHADER_STAGE_GEOMETRY_BIT & value) strings.push_back("SHADER_STAGE_GEOMETRY_BIT");
+    if (VK_SHADER_STAGE_FRAGMENT_BIT & value) strings.push_back("SHADER_STAGE_FRAGMENT_BIT");
+    if (VK_SHADER_STAGE_COMPUTE_BIT & value) strings.push_back("SHADER_STAGE_COMPUTE_BIT");
+    if (VK_SHADER_STAGE_RAYGEN_BIT_KHR & value) strings.push_back("SHADER_STAGE_RAYGEN_BIT_KHR");
+    if (VK_SHADER_STAGE_ANY_HIT_BIT_KHR & value) strings.push_back("SHADER_STAGE_ANY_HIT_BIT_KHR");
+    if (VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR & value) strings.push_back("SHADER_STAGE_CLOSEST_HIT_BIT_KHR");
+    if (VK_SHADER_STAGE_MISS_BIT_KHR & value) strings.push_back("SHADER_STAGE_MISS_BIT_KHR");
+    if (VK_SHADER_STAGE_INTERSECTION_BIT_KHR & value) strings.push_back("SHADER_STAGE_INTERSECTION_BIT_KHR");
+    if (VK_SHADER_STAGE_CALLABLE_BIT_KHR & value) strings.push_back("SHADER_STAGE_CALLABLE_BIT_KHR");
+    if (VK_SHADER_STAGE_TASK_BIT_EXT & value) strings.push_back("SHADER_STAGE_TASK_BIT_EXT");
+    if (VK_SHADER_STAGE_MESH_BIT_EXT & value) strings.push_back("SHADER_STAGE_MESH_BIT_EXT");
+    if (VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI & value) strings.push_back("SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI");
+    if (VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI & value) strings.push_back("SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI");
+    return strings;
+}
+void DumpVkShaderStageFlags(Printer &p, std::string name, VkShaderStageFlags value) {
+    if (static_cast<VkShaderStageFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkShaderStageFlagBitsGetStrings(static_cast<VkShaderStageFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkShaderStageFlagBits(Printer &p, std::string name, VkShaderStageFlagBits value) {
+    auto strings = VkShaderStageFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkSubgroupFeatureFlagBitsGetStrings(VkSubgroupFeatureFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_SUBGROUP_FEATURE_BASIC_BIT & value) strings.push_back("SUBGROUP_FEATURE_BASIC_BIT");
+    if (VK_SUBGROUP_FEATURE_VOTE_BIT & value) strings.push_back("SUBGROUP_FEATURE_VOTE_BIT");
+    if (VK_SUBGROUP_FEATURE_ARITHMETIC_BIT & value) strings.push_back("SUBGROUP_FEATURE_ARITHMETIC_BIT");
+    if (VK_SUBGROUP_FEATURE_BALLOT_BIT & value) strings.push_back("SUBGROUP_FEATURE_BALLOT_BIT");
+    if (VK_SUBGROUP_FEATURE_SHUFFLE_BIT & value) strings.push_back("SUBGROUP_FEATURE_SHUFFLE_BIT");
+    if (VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT & value) strings.push_back("SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT");
+    if (VK_SUBGROUP_FEATURE_CLUSTERED_BIT & value) strings.push_back("SUBGROUP_FEATURE_CLUSTERED_BIT");
+    if (VK_SUBGROUP_FEATURE_QUAD_BIT & value) strings.push_back("SUBGROUP_FEATURE_QUAD_BIT");
+    if (VK_SUBGROUP_FEATURE_ROTATE_BIT & value) strings.push_back("SUBGROUP_FEATURE_ROTATE_BIT");
+    if (VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT & value) strings.push_back("SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT");
+    if (VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT & value) strings.push_back("SUBGROUP_FEATURE_PARTITIONED_BIT_EXT");
+    return strings;
+}
+void DumpVkSubgroupFeatureFlags(Printer &p, std::string name, VkSubgroupFeatureFlags value) {
+    if (static_cast<VkSubgroupFeatureFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkSubgroupFeatureFlagBitsGetStrings(static_cast<VkSubgroupFeatureFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkSubgroupFeatureFlagBits(Printer &p, std::string name, VkSubgroupFeatureFlagBits value) {
+    auto strings = VkSubgroupFeatureFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkSurfaceCounterFlagBitsEXTGetStrings(VkSurfaceCounterFlagBitsEXT value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_SURFACE_COUNTER_VBLANK_BIT_EXT & value) strings.push_back("SURFACE_COUNTER_VBLANK_BIT_EXT");
+    return strings;
+}
+void DumpVkSurfaceCounterFlagsEXT(Printer &p, std::string name, VkSurfaceCounterFlagsEXT value) {
+    if (static_cast<VkSurfaceCounterFlagBitsEXT>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkSurfaceCounterFlagBitsEXTGetStrings(static_cast<VkSurfaceCounterFlagBitsEXT>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkSurfaceCounterFlagBitsEXT(Printer &p, std::string name, VkSurfaceCounterFlagBitsEXT value) {
+    auto strings = VkSurfaceCounterFlagBitsEXTGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkSurfaceTransformFlagBitsKHRGetStrings(VkSurfaceTransformFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_IDENTITY_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_90_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_180_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_270_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR & value)
+        strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR & value)
+        strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR & value)
+        strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_INHERIT_BIT_KHR");
+    return strings;
+}
+void DumpVkSurfaceTransformFlagsKHR(Printer &p, std::string name, VkSurfaceTransformFlagsKHR value) {
+    if (static_cast<VkSurfaceTransformFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkSurfaceTransformFlagBitsKHRGetStrings(static_cast<VkSurfaceTransformFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkSurfaceTransformFlagBitsKHR(Printer &p, std::string name, VkSurfaceTransformFlagBitsKHR value) {
+    auto strings = VkSurfaceTransformFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkToolPurposeFlagBitsGetStrings(VkToolPurposeFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_TOOL_PURPOSE_VALIDATION_BIT & value) strings.push_back("TOOL_PURPOSE_VALIDATION_BIT");
+    if (VK_TOOL_PURPOSE_PROFILING_BIT & value) strings.push_back("TOOL_PURPOSE_PROFILING_BIT");
+    if (VK_TOOL_PURPOSE_TRACING_BIT & value) strings.push_back("TOOL_PURPOSE_TRACING_BIT");
+    if (VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT & value) strings.push_back("TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT");
+    if (VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT & value) strings.push_back("TOOL_PURPOSE_MODIFYING_FEATURES_BIT");
+    if (VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT & value) strings.push_back("TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT");
+    if (VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT & value) strings.push_back("TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT");
+    return strings;
+}
+void DumpVkToolPurposeFlags(Printer &p, std::string name, VkToolPurposeFlags value) {
+    if (static_cast<VkToolPurposeFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkToolPurposeFlagBitsGetStrings(static_cast<VkToolPurposeFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkToolPurposeFlagBits(Printer &p, std::string name, VkToolPurposeFlagBits value) {
+    auto strings = VkToolPurposeFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoCapabilityFlagBitsKHRGetStrings(VkVideoCapabilityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR & value) strings.push_back("VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR");
+    if (VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR & value)
+        strings.push_back("VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoCapabilityFlagsKHR(Printer &p, std::string name, VkVideoCapabilityFlagsKHR value) {
+    if (static_cast<VkVideoCapabilityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoCapabilityFlagBitsKHRGetStrings(static_cast<VkVideoCapabilityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoCapabilityFlagBitsKHR(Printer &p, std::string name, VkVideoCapabilityFlagBitsKHR value) {
+    auto strings = VkVideoCapabilityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoChromaSubsamplingFlagBitsKHRGetStrings(VkVideoChromaSubsamplingFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR & value) strings.push_back("VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR");
+    if (VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR & value) strings.push_back("VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR");
+    if (VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR & value) strings.push_back("VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR");
+    if (VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR & value) strings.push_back("VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoChromaSubsamplingFlagsKHR(Printer &p, std::string name, VkVideoChromaSubsamplingFlagsKHR value) {
+    if (static_cast<VkVideoChromaSubsamplingFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoChromaSubsamplingFlagBitsKHRGetStrings(static_cast<VkVideoChromaSubsamplingFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoChromaSubsamplingFlagBitsKHR(Printer &p, std::string name, VkVideoChromaSubsamplingFlagBitsKHR value) {
+    auto strings = VkVideoChromaSubsamplingFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoCodecOperationFlagBitsKHRGetStrings(VkVideoCodecOperationFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_CODEC_OPERATION_NONE_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR");
+    if (VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR");
+    if (VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR");
+    if (VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR");
+    if (VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR");
+    if (VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR");
+    if (VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoCodecOperationFlagsKHR(Printer &p, std::string name, VkVideoCodecOperationFlagsKHR value) {
+    if (static_cast<VkVideoCodecOperationFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoCodecOperationFlagBitsKHRGetStrings(static_cast<VkVideoCodecOperationFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoCodecOperationFlagBitsKHR(Printer &p, std::string name, VkVideoCodecOperationFlagBitsKHR value) {
+    auto strings = VkVideoCodecOperationFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoComponentBitDepthFlagBitsKHRGetStrings(VkVideoComponentBitDepthFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR & value) strings.push_back("VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR");
+    if (VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR & value) strings.push_back("VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR");
+    if (VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR & value) strings.push_back("VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoComponentBitDepthFlagsKHR(Printer &p, std::string name, VkVideoComponentBitDepthFlagsKHR value) {
+    if (static_cast<VkVideoComponentBitDepthFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoComponentBitDepthFlagBitsKHRGetStrings(static_cast<VkVideoComponentBitDepthFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoComponentBitDepthFlagBitsKHR(Printer &p, std::string name, VkVideoComponentBitDepthFlagBitsKHR value) {
+    auto strings = VkVideoComponentBitDepthFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoDecodeCapabilityFlagBitsKHRGetStrings(VkVideoDecodeCapabilityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR & value)
+        strings.push_back("VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR");
+    if (VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR & value)
+        strings.push_back("VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoDecodeCapabilityFlagsKHR(Printer &p, std::string name, VkVideoDecodeCapabilityFlagsKHR value) {
+    if (static_cast<VkVideoDecodeCapabilityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoDecodeCapabilityFlagBitsKHRGetStrings(static_cast<VkVideoDecodeCapabilityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoDecodeCapabilityFlagBitsKHR(Printer &p, std::string name, VkVideoDecodeCapabilityFlagBitsKHR value) {
+    auto strings = VkVideoDecodeCapabilityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoDecodeH264PictureLayoutFlagBitsKHRGetStrings(VkVideoDecodeH264PictureLayoutFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR & value)
+        strings.push_back("VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR");
+    if (VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR & value)
+        strings.push_back("VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoDecodeH264PictureLayoutFlagsKHR(Printer &p, std::string name, VkVideoDecodeH264PictureLayoutFlagsKHR value) {
+    if (static_cast<VkVideoDecodeH264PictureLayoutFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings =
+        VkVideoDecodeH264PictureLayoutFlagBitsKHRGetStrings(static_cast<VkVideoDecodeH264PictureLayoutFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoDecodeH264PictureLayoutFlagBitsKHR(Printer &p, std::string name, VkVideoDecodeH264PictureLayoutFlagBitsKHR value) {
+    auto strings = VkVideoDecodeH264PictureLayoutFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoDecodeUsageFlagBitsKHRGetStrings(VkVideoDecodeUsageFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_DECODE_USAGE_DEFAULT_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR & value) strings.push_back("VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR");
+    if (VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR & value) strings.push_back("VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR");
+    if (VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR & value) strings.push_back("VIDEO_DECODE_USAGE_STREAMING_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoDecodeUsageFlagsKHR(Printer &p, std::string name, VkVideoDecodeUsageFlagsKHR value) {
+    if (static_cast<VkVideoDecodeUsageFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoDecodeUsageFlagBitsKHRGetStrings(static_cast<VkVideoDecodeUsageFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoDecodeUsageFlagBitsKHR(Printer &p, std::string name, VkVideoDecodeUsageFlagBitsKHR value) {
+    auto strings = VkVideoDecodeUsageFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeAV1CapabilityFlagBitsKHRGetStrings(VkVideoEncodeAV1CapabilityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeAV1CapabilityFlagsKHR(Printer &p, std::string name, VkVideoEncodeAV1CapabilityFlagsKHR value) {
+    if (static_cast<VkVideoEncodeAV1CapabilityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeAV1CapabilityFlagBitsKHRGetStrings(static_cast<VkVideoEncodeAV1CapabilityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeAV1CapabilityFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeAV1CapabilityFlagBitsKHR value) {
+    auto strings = VkVideoEncodeAV1CapabilityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeAV1StdFlagBitsKHRGetStrings(VkVideoEncodeAV1StdFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeAV1StdFlagsKHR(Printer &p, std::string name, VkVideoEncodeAV1StdFlagsKHR value) {
+    if (static_cast<VkVideoEncodeAV1StdFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeAV1StdFlagBitsKHRGetStrings(static_cast<VkVideoEncodeAV1StdFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeAV1StdFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeAV1StdFlagBitsKHR value) {
+    auto strings = VkVideoEncodeAV1StdFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeAV1SuperblockSizeFlagBitsKHRGetStrings(VkVideoEncodeAV1SuperblockSizeFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeAV1SuperblockSizeFlagsKHR(Printer &p, std::string name, VkVideoEncodeAV1SuperblockSizeFlagsKHR value) {
+    if (static_cast<VkVideoEncodeAV1SuperblockSizeFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings =
+        VkVideoEncodeAV1SuperblockSizeFlagBitsKHRGetStrings(static_cast<VkVideoEncodeAV1SuperblockSizeFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeAV1SuperblockSizeFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeAV1SuperblockSizeFlagBitsKHR value) {
+    auto strings = VkVideoEncodeAV1SuperblockSizeFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeCapabilityFlagBitsKHRGetStrings(VkVideoEncodeCapabilityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR");
+    if (VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR");
+    if (VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR");
+    if (VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeCapabilityFlagsKHR(Printer &p, std::string name, VkVideoEncodeCapabilityFlagsKHR value) {
+    if (static_cast<VkVideoEncodeCapabilityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeCapabilityFlagBitsKHRGetStrings(static_cast<VkVideoEncodeCapabilityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeCapabilityFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeCapabilityFlagBitsKHR value) {
+    auto strings = VkVideoEncodeCapabilityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeContentFlagBitsKHRGetStrings(VkVideoEncodeContentFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_ENCODE_CONTENT_DEFAULT_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR");
+    if (VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR");
+    if (VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeContentFlagsKHR(Printer &p, std::string name, VkVideoEncodeContentFlagsKHR value) {
+    if (static_cast<VkVideoEncodeContentFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeContentFlagBitsKHRGetStrings(static_cast<VkVideoEncodeContentFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeContentFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeContentFlagBitsKHR value) {
+    auto strings = VkVideoEncodeContentFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeFeedbackFlagBitsKHRGetStrings(VkVideoEncodeFeedbackFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR");
+    if (VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeFeedbackFlagsKHR(Printer &p, std::string name, VkVideoEncodeFeedbackFlagsKHR value) {
+    if (static_cast<VkVideoEncodeFeedbackFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeFeedbackFlagBitsKHRGetStrings(static_cast<VkVideoEncodeFeedbackFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeFeedbackFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeFeedbackFlagBitsKHR value) {
+    auto strings = VkVideoEncodeFeedbackFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeH264CapabilityFlagBitsKHRGetStrings(VkVideoEncodeH264CapabilityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeH264CapabilityFlagsKHR(Printer &p, std::string name, VkVideoEncodeH264CapabilityFlagsKHR value) {
+    if (static_cast<VkVideoEncodeH264CapabilityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeH264CapabilityFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH264CapabilityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeH264CapabilityFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeH264CapabilityFlagBitsKHR value) {
+    auto strings = VkVideoEncodeH264CapabilityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeH264StdFlagBitsKHRGetStrings(VkVideoEncodeH264StdFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeH264StdFlagsKHR(Printer &p, std::string name, VkVideoEncodeH264StdFlagsKHR value) {
+    if (static_cast<VkVideoEncodeH264StdFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeH264StdFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH264StdFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeH264StdFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeH264StdFlagBitsKHR value) {
+    auto strings = VkVideoEncodeH264StdFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeH265CapabilityFlagBitsKHRGetStrings(VkVideoEncodeH265CapabilityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeH265CapabilityFlagsKHR(Printer &p, std::string name, VkVideoEncodeH265CapabilityFlagsKHR value) {
+    if (static_cast<VkVideoEncodeH265CapabilityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeH265CapabilityFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH265CapabilityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeH265CapabilityFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeH265CapabilityFlagBitsKHR value) {
+    auto strings = VkVideoEncodeH265CapabilityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeH265CtbSizeFlagBitsKHRGetStrings(VkVideoEncodeH265CtbSizeFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeH265CtbSizeFlagsKHR(Printer &p, std::string name, VkVideoEncodeH265CtbSizeFlagsKHR value) {
+    if (static_cast<VkVideoEncodeH265CtbSizeFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeH265CtbSizeFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH265CtbSizeFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeH265CtbSizeFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeH265CtbSizeFlagBitsKHR value) {
+    auto strings = VkVideoEncodeH265CtbSizeFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeH265StdFlagBitsKHRGetStrings(VkVideoEncodeH265StdFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeH265StdFlagsKHR(Printer &p, std::string name, VkVideoEncodeH265StdFlagsKHR value) {
+    if (static_cast<VkVideoEncodeH265StdFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeH265StdFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH265StdFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeH265StdFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeH265StdFlagBitsKHR value) {
+    auto strings = VkVideoEncodeH265StdFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeH265TransformBlockSizeFlagBitsKHRGetStrings(
+    VkVideoEncodeH265TransformBlockSizeFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeH265TransformBlockSizeFlagsKHR(Printer &p, std::string name,
+                                                     VkVideoEncodeH265TransformBlockSizeFlagsKHR value) {
+    if (static_cast<VkVideoEncodeH265TransformBlockSizeFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeH265TransformBlockSizeFlagBitsKHRGetStrings(
+        static_cast<VkVideoEncodeH265TransformBlockSizeFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeH265TransformBlockSizeFlagBitsKHR(Printer &p, std::string name,
+                                                        VkVideoEncodeH265TransformBlockSizeFlagBitsKHR value) {
+    auto strings = VkVideoEncodeH265TransformBlockSizeFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeIntraRefreshModeFlagBitsKHRGetStrings(VkVideoEncodeIntraRefreshModeFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR");
+    if (VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeIntraRefreshModeFlagsKHR(Printer &p, std::string name, VkVideoEncodeIntraRefreshModeFlagsKHR value) {
+    if (static_cast<VkVideoEncodeIntraRefreshModeFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeIntraRefreshModeFlagBitsKHRGetStrings(static_cast<VkVideoEncodeIntraRefreshModeFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeIntraRefreshModeFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeIntraRefreshModeFlagBitsKHR value) {
+    auto strings = VkVideoEncodeIntraRefreshModeFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeRateControlModeFlagBitsKHRGetStrings(VkVideoEncodeRateControlModeFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR");
+    if (VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeRateControlModeFlagsKHR(Printer &p, std::string name, VkVideoEncodeRateControlModeFlagsKHR value) {
+    if (static_cast<VkVideoEncodeRateControlModeFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeRateControlModeFlagBitsKHRGetStrings(static_cast<VkVideoEncodeRateControlModeFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeRateControlModeFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeRateControlModeFlagBitsKHR value) {
+    auto strings = VkVideoEncodeRateControlModeFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeRgbChromaOffsetFlagBitsVALVEGetStrings(VkVideoEncodeRgbChromaOffsetFlagBitsVALVE value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE");
+    if (VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE");
+    return strings;
+}
+void DumpVkVideoEncodeRgbChromaOffsetFlagsVALVE(Printer &p, std::string name, VkVideoEncodeRgbChromaOffsetFlagsVALVE value) {
+    if (static_cast<VkVideoEncodeRgbChromaOffsetFlagBitsVALVE>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings =
+        VkVideoEncodeRgbChromaOffsetFlagBitsVALVEGetStrings(static_cast<VkVideoEncodeRgbChromaOffsetFlagBitsVALVE>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeRgbChromaOffsetFlagBitsVALVE(Printer &p, std::string name, VkVideoEncodeRgbChromaOffsetFlagBitsVALVE value) {
+    auto strings = VkVideoEncodeRgbChromaOffsetFlagBitsVALVEGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeRgbModelConversionFlagBitsVALVEGetStrings(
+    VkVideoEncodeRgbModelConversionFlagBitsVALVE value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE");
+    if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE");
+    if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE");
+    if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE");
+    if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE");
+    return strings;
+}
+void DumpVkVideoEncodeRgbModelConversionFlagsVALVE(Printer &p, std::string name, VkVideoEncodeRgbModelConversionFlagsVALVE value) {
+    if (static_cast<VkVideoEncodeRgbModelConversionFlagBitsVALVE>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings =
+        VkVideoEncodeRgbModelConversionFlagBitsVALVEGetStrings(static_cast<VkVideoEncodeRgbModelConversionFlagBitsVALVE>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeRgbModelConversionFlagBitsVALVE(Printer &p, std::string name,
+                                                      VkVideoEncodeRgbModelConversionFlagBitsVALVE value) {
+    auto strings = VkVideoEncodeRgbModelConversionFlagBitsVALVEGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeRgbRangeCompressionFlagBitsVALVEGetStrings(
+    VkVideoEncodeRgbRangeCompressionFlagBitsVALVE value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE");
+    if (VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE");
+    return strings;
+}
+void DumpVkVideoEncodeRgbRangeCompressionFlagsVALVE(Printer &p, std::string name,
+                                                    VkVideoEncodeRgbRangeCompressionFlagsVALVE value) {
+    if (static_cast<VkVideoEncodeRgbRangeCompressionFlagBitsVALVE>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings =
+        VkVideoEncodeRgbRangeCompressionFlagBitsVALVEGetStrings(static_cast<VkVideoEncodeRgbRangeCompressionFlagBitsVALVE>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeRgbRangeCompressionFlagBitsVALVE(Printer &p, std::string name,
+                                                       VkVideoEncodeRgbRangeCompressionFlagBitsVALVE value) {
+    auto strings = VkVideoEncodeRgbRangeCompressionFlagBitsVALVEGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeUsageFlagBitsKHRGetStrings(VkVideoEncodeUsageFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_ENCODE_USAGE_DEFAULT_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR");
+    if (VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR");
+    if (VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR");
+    if (VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeUsageFlagsKHR(Printer &p, std::string name, VkVideoEncodeUsageFlagsKHR value) {
+    if (static_cast<VkVideoEncodeUsageFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeUsageFlagBitsKHRGetStrings(static_cast<VkVideoEncodeUsageFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeUsageFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeUsageFlagBitsKHR value) {
+    auto strings = VkVideoEncodeUsageFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+void DumpVkComponentMapping(Printer &p, std::string name, const VkComponentMapping &obj);
+void DumpVkConformanceVersion(Printer &p, std::string name, const VkConformanceVersion &obj);
+void DumpVkCooperativeMatrixPropertiesKHR(Printer &p, std::string name, const VkCooperativeMatrixPropertiesKHR &obj);
+void DumpVkDisplayModeParametersKHR(Printer &p, std::string name, const VkDisplayModeParametersKHR &obj);
+void DumpVkDisplayModePropertiesKHR(Printer &p, std::string name, const VkDisplayModePropertiesKHR &obj);
+void DumpVkDisplayPlaneCapabilitiesKHR(Printer &p, std::string name, const VkDisplayPlaneCapabilitiesKHR &obj);
+void DumpVkDisplayPlanePropertiesKHR(Printer &p, std::string name, const VkDisplayPlanePropertiesKHR &obj);
+void DumpVkDisplayPropertiesKHR(Printer &p, std::string name, const VkDisplayPropertiesKHR &obj);
+void DumpVkDrmFormatModifierProperties2EXT(Printer &p, std::string name, const VkDrmFormatModifierProperties2EXT &obj);
+void DumpVkExtensionProperties(Printer &p, std::string name, const VkExtensionProperties &obj);
+void DumpVkExtent2D(Printer &p, std::string name, const VkExtent2D &obj);
+void DumpVkExtent3D(Printer &p, std::string name, const VkExtent3D &obj);
+void DumpVkFormatProperties(Printer &p, std::string name, const VkFormatProperties &obj);
+void DumpVkFormatProperties3(Printer &p, std::string name, const VkFormatProperties3 &obj);
+void DumpVkLayerProperties(Printer &p, std::string name, const VkLayerProperties &obj);
+void DumpVkMultisamplePropertiesEXT(Printer &p, std::string name, const VkMultisamplePropertiesEXT &obj);
+void DumpVkOffset2D(Printer &p, std::string name, const VkOffset2D &obj);
+void DumpVkPhysicalDevice16BitStorageFeatures(Printer &p, std::string name, const VkPhysicalDevice16BitStorageFeatures &obj);
+void DumpVkPhysicalDevice4444FormatsFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevice4444FormatsFeaturesEXT &obj);
+void DumpVkPhysicalDevice8BitStorageFeatures(Printer &p, std::string name, const VkPhysicalDevice8BitStorageFeatures &obj);
+void DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceASTCDecodeFeaturesEXT &obj);
+void DumpVkPhysicalDeviceAccelerationStructureFeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceAccelerationStructureFeaturesKHR &obj);
+void DumpVkPhysicalDeviceAccelerationStructurePropertiesKHR(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceAccelerationStructurePropertiesKHR &obj);
+void DumpVkPhysicalDeviceAddressBindingReportFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceAddressBindingReportFeaturesEXT &obj);
+void DumpVkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT &obj);
+void DumpVkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT &obj);
+void DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &obj);
+void DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &obj);
+void DumpVkPhysicalDeviceBorderColorSwizzleFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT &obj);
+void DumpVkPhysicalDeviceBufferDeviceAddressFeatures(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceBufferDeviceAddressFeatures &obj);
+void DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &obj);
+void DumpVkPhysicalDeviceColorWriteEnableFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceColorWriteEnableFeaturesEXT &obj);
+void DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR &obj);
+void DumpVkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR &obj);
+void DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceConditionalRenderingFeaturesEXT &obj);
+void DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceConservativeRasterizationPropertiesEXT &obj);
+void DumpVkPhysicalDeviceCooperativeMatrixFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceCooperativeMatrixFeaturesKHR &obj);
+void DumpVkPhysicalDeviceCooperativeMatrixPropertiesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceCooperativeMatrixPropertiesKHR &obj);
+void DumpVkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR &obj);
+void DumpVkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR &obj);
+void DumpVkPhysicalDeviceCustomBorderColorFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceCustomBorderColorFeaturesEXT &obj);
+void DumpVkPhysicalDeviceCustomBorderColorPropertiesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceCustomBorderColorPropertiesEXT &obj);
+void DumpVkPhysicalDeviceCustomResolveFeaturesEXT(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceCustomResolveFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDepthBiasControlFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDepthBiasControlFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDepthClampControlFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceDepthClampControlFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDepthClampZeroOneFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR &obj);
+void DumpVkPhysicalDeviceDepthClipControlFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDepthClipControlFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceDepthClipEnableFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDepthStencilResolveProperties(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDepthStencilResolveProperties &obj);
+void DumpVkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT &obj);
+void DumpVkPhysicalDeviceDescriptorBufferFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDescriptorBufferFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDescriptorBufferPropertiesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDescriptorBufferPropertiesEXT &obj);
+void DumpVkPhysicalDeviceDescriptorHeapFeaturesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceDescriptorHeapFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDescriptorHeapPropertiesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDescriptorHeapPropertiesEXT &obj);
+void DumpVkPhysicalDeviceDescriptorHeapTensorPropertiesARM(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM &obj);
+void DumpVkPhysicalDeviceDescriptorIndexingFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceDescriptorIndexingFeatures &obj);
+void DumpVkPhysicalDeviceDescriptorIndexingProperties(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceDescriptorIndexingProperties &obj);
+void DumpVkPhysicalDeviceDeviceAddressCommandsFeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR &obj);
+void DumpVkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT &obj);
+void DumpVkPhysicalDeviceDeviceMemoryReportFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDiscardRectanglePropertiesEXT &obj);
+void DumpVkPhysicalDeviceDriverProperties(Printer &p, std::string name, const VkPhysicalDeviceDriverProperties &obj);
+void DumpVkPhysicalDeviceDrmPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceDrmPropertiesEXT &obj);
+void DumpVkPhysicalDeviceDynamicRenderingFeatures(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceDynamicRenderingFeatures &obj);
+void DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceDynamicRenderingLocalReadFeatures &obj);
+void DumpVkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT &obj);
+void DumpVkPhysicalDeviceExtendedDynamicState2FeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &obj);
+void DumpVkPhysicalDeviceExtendedDynamicState3FeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT &obj);
+void DumpVkPhysicalDeviceExtendedDynamicState3PropertiesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT &obj);
+void DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &obj);
+void DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceExternalMemoryHostPropertiesEXT &obj);
+void DumpVkPhysicalDeviceFaultFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceFaultFeaturesEXT &obj);
+void DumpVkPhysicalDeviceFaultFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceFaultFeaturesKHR &obj);
+void DumpVkPhysicalDeviceFaultPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceFaultPropertiesKHR &obj);
+void DumpVkPhysicalDeviceFeatures(Printer &p, std::string name, const VkPhysicalDeviceFeatures &obj);
+void DumpVkPhysicalDeviceFloatControlsProperties(Printer &p, std::string name, const VkPhysicalDeviceFloatControlsProperties &obj);
+void DumpVkPhysicalDeviceFragmentDensityMap2FeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &obj);
+void DumpVkPhysicalDeviceFragmentDensityMap2PropertiesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &obj);
+void DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceFragmentDensityMapFeaturesEXT &obj);
+void DumpVkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &obj);
+void DumpVkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT &obj);
+void DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceFragmentDensityMapPropertiesEXT &obj);
+void DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR &obj);
+void DumpVkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR &obj);
+void DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &obj);
+void DumpVkPhysicalDeviceFragmentShadingRateFeaturesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceFragmentShadingRateFeaturesKHR &obj);
+void DumpVkPhysicalDeviceFragmentShadingRateKHR(Printer &p, std::string name, const VkPhysicalDeviceFragmentShadingRateKHR &obj);
+void DumpVkPhysicalDeviceFragmentShadingRatePropertiesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceFragmentShadingRatePropertiesKHR &obj);
+void DumpVkPhysicalDeviceFrameBoundaryFeaturesEXT(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceFrameBoundaryFeaturesEXT &obj);
+void DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceGlobalPriorityQueryFeatures &obj);
+void DumpVkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT &obj);
+void DumpVkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT &obj);
+void DumpVkPhysicalDeviceHostImageCopyFeatures(Printer &p, std::string name, const VkPhysicalDeviceHostImageCopyFeatures &obj);
+void DumpVkPhysicalDeviceHostImageCopyProperties(Printer &p, std::string name, const VkPhysicalDeviceHostImageCopyProperties &obj);
+void DumpVkPhysicalDeviceHostQueryResetFeatures(Printer &p, std::string name, const VkPhysicalDeviceHostQueryResetFeatures &obj);
+void DumpVkPhysicalDeviceIDProperties(Printer &p, std::string name, const VkPhysicalDeviceIDProperties &obj);
+void DumpVkPhysicalDeviceImage2DViewOf3DFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT &obj);
+void DumpVkPhysicalDeviceImageCompressionControlFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceImageCompressionControlFeaturesEXT &obj);
+void DumpVkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT &obj);
+void DumpVkPhysicalDeviceImageRobustnessFeatures(Printer &p, std::string name, const VkPhysicalDeviceImageRobustnessFeatures &obj);
+void DumpVkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT &obj);
+void DumpVkPhysicalDeviceImageViewMinLodFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceImageViewMinLodFeaturesEXT &obj);
+void DumpVkPhysicalDeviceImagelessFramebufferFeatures(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceImagelessFramebufferFeatures &obj);
+void DumpVkPhysicalDeviceIndexTypeUint8Features(Printer &p, std::string name, const VkPhysicalDeviceIndexTypeUint8Features &obj);
+void DumpVkPhysicalDeviceInlineUniformBlockFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceInlineUniformBlockFeatures &obj);
+void DumpVkPhysicalDeviceInlineUniformBlockProperties(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceInlineUniformBlockProperties &obj);
+void DumpVkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR &obj);
+void DumpVkPhysicalDeviceLayeredApiPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceLayeredApiPropertiesKHR &obj);
+void DumpVkPhysicalDeviceLayeredApiPropertiesListKHR(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceLayeredApiPropertiesListKHR &obj);
+void DumpVkPhysicalDeviceLegacyDitheringFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceLegacyDitheringFeaturesEXT &obj);
+void DumpVkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT &obj);
+void DumpVkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT &obj);
+void DumpVkPhysicalDeviceLimits(Printer &p, std::string name, const VkPhysicalDeviceLimits &obj);
+void DumpVkPhysicalDeviceLineRasterizationFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceLineRasterizationFeatures &obj);
+void DumpVkPhysicalDeviceLineRasterizationProperties(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceLineRasterizationProperties &obj);
+void DumpVkPhysicalDeviceMaintenance10FeaturesKHR(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceMaintenance10FeaturesKHR &obj);
+void DumpVkPhysicalDeviceMaintenance10PropertiesKHR(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceMaintenance10PropertiesKHR &obj);
+void DumpVkPhysicalDeviceMaintenance3Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance3Properties &obj);
+void DumpVkPhysicalDeviceMaintenance4Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance4Features &obj);
+void DumpVkPhysicalDeviceMaintenance4Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance4Properties &obj);
+void DumpVkPhysicalDeviceMaintenance5Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance5Features &obj);
+void DumpVkPhysicalDeviceMaintenance5Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance5Properties &obj);
+void DumpVkPhysicalDeviceMaintenance6Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance6Features &obj);
+void DumpVkPhysicalDeviceMaintenance6Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance6Properties &obj);
+void DumpVkPhysicalDeviceMaintenance7FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance7FeaturesKHR &obj);
+void DumpVkPhysicalDeviceMaintenance7PropertiesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMaintenance7PropertiesKHR &obj);
+void DumpVkPhysicalDeviceMaintenance8FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance8FeaturesKHR &obj);
+void DumpVkPhysicalDeviceMaintenance9FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance9FeaturesKHR &obj);
+void DumpVkPhysicalDeviceMaintenance9PropertiesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMaintenance9PropertiesKHR &obj);
+void DumpVkPhysicalDeviceMapMemoryPlacedFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT &obj);
+void DumpVkPhysicalDeviceMapMemoryPlacedPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT &obj);
+void DumpVkPhysicalDeviceMemoryBudgetPropertiesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMemoryBudgetPropertiesEXT &obj);
+void DumpVkPhysicalDeviceMemoryDecompressionFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceMemoryDecompressionFeaturesEXT &obj);
+void DumpVkPhysicalDeviceMemoryDecompressionPropertiesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceMemoryDecompressionPropertiesEXT &obj);
+void DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMemoryPriorityFeaturesEXT &obj);
+void DumpVkPhysicalDeviceMeshShaderFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMeshShaderFeaturesEXT &obj);
+void DumpVkPhysicalDeviceMeshShaderPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceMeshShaderPropertiesEXT &obj);
+void DumpVkPhysicalDeviceMultiDrawFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMultiDrawFeaturesEXT &obj);
+void DumpVkPhysicalDeviceMultiDrawPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceMultiDrawPropertiesEXT &obj);
+void DumpVkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT &obj);
+void DumpVkPhysicalDeviceMultiviewFeatures(Printer &p, std::string name, const VkPhysicalDeviceMultiviewFeatures &obj);
+void DumpVkPhysicalDeviceMultiviewProperties(Printer &p, std::string name, const VkPhysicalDeviceMultiviewProperties &obj);
+void DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT &obj);
+void DumpVkPhysicalDeviceNestedCommandBufferFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceNestedCommandBufferFeaturesEXT &obj);
+void DumpVkPhysicalDeviceNestedCommandBufferPropertiesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceNestedCommandBufferPropertiesEXT &obj);
+void DumpVkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT &obj);
+void DumpVkPhysicalDeviceOpacityMicromapFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceOpacityMicromapFeaturesEXT &obj);
+void DumpVkPhysicalDeviceOpacityMicromapPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceOpacityMicromapPropertiesEXT &obj);
+void DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(Printer &p, std::string name, const VkPhysicalDevicePCIBusInfoPropertiesEXT &obj);
+void DumpVkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT &obj);
+void DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(Printer &p, std::string name,
+                                                     const VkPhysicalDevicePerformanceQueryFeaturesKHR &obj);
+void DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDevicePerformanceQueryPropertiesKHR &obj);
+void DumpVkPhysicalDevicePipelineBinaryFeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDevicePipelineBinaryFeaturesKHR &obj);
+void DumpVkPhysicalDevicePipelineBinaryPropertiesKHR(Printer &p, std::string name,
+                                                     const VkPhysicalDevicePipelineBinaryPropertiesKHR &obj);
+void DumpVkPhysicalDevicePipelineCreationCacheControlFeatures(Printer &p, std::string name,
+                                                              const VkPhysicalDevicePipelineCreationCacheControlFeatures &obj);
+void DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &obj);
+void DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(Printer &p, std::string name,
+                                                                const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT &obj);
+void DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDevicePipelinePropertiesFeaturesEXT &obj);
+void DumpVkPhysicalDevicePipelineProtectedAccessFeatures(Printer &p, std::string name,
+                                                         const VkPhysicalDevicePipelineProtectedAccessFeatures &obj);
+void DumpVkPhysicalDevicePipelineRobustnessFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDevicePipelineRobustnessFeatures &obj);
+void DumpVkPhysicalDevicePipelineRobustnessProperties(Printer &p, std::string name,
+                                                      const VkPhysicalDevicePipelineRobustnessProperties &obj);
+void DumpVkPhysicalDevicePointClippingProperties(Printer &p, std::string name, const VkPhysicalDevicePointClippingProperties &obj);
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+void DumpVkPhysicalDevicePortabilitySubsetFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDevicePortabilitySubsetFeaturesKHR &obj);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+void DumpVkPhysicalDevicePortabilitySubsetPropertiesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDevicePortabilitySubsetPropertiesKHR &obj);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+void DumpVkPhysicalDevicePresentId2FeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentId2FeaturesKHR &obj);
+void DumpVkPhysicalDevicePresentIdFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentIdFeaturesKHR &obj);
+void DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR &obj);
+void DumpVkPhysicalDevicePresentTimingFeaturesEXT(Printer &p, std::string name,
+                                                  const VkPhysicalDevicePresentTimingFeaturesEXT &obj);
+void DumpVkPhysicalDevicePresentWait2FeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentWait2FeaturesKHR &obj);
+void DumpVkPhysicalDevicePresentWaitFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentWaitFeaturesKHR &obj);
+void DumpVkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT &obj);
+void DumpVkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT &obj);
+void DumpVkPhysicalDevicePrivateDataFeatures(Printer &p, std::string name, const VkPhysicalDevicePrivateDataFeatures &obj);
+void DumpVkPhysicalDeviceProtectedMemoryFeatures(Printer &p, std::string name, const VkPhysicalDeviceProtectedMemoryFeatures &obj);
+void DumpVkPhysicalDeviceProtectedMemoryProperties(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceProtectedMemoryProperties &obj);
+void DumpVkPhysicalDeviceProvokingVertexFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceProvokingVertexFeaturesEXT &obj);
+void DumpVkPhysicalDeviceProvokingVertexPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceProvokingVertexPropertiesEXT &obj);
+void DumpVkPhysicalDevicePushDescriptorProperties(Printer &p, std::string name,
+                                                  const VkPhysicalDevicePushDescriptorProperties &obj);
+void DumpVkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT &obj);
+void DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT &obj);
+void DumpVkPhysicalDeviceRayQueryFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceRayQueryFeaturesKHR &obj);
+void DumpVkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT &obj);
+void DumpVkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT &obj);
+void DumpVkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR &obj);
+void DumpVkPhysicalDeviceRayTracingPipelineFeaturesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceRayTracingPipelineFeaturesKHR &obj);
+void DumpVkPhysicalDeviceRayTracingPipelinePropertiesKHR(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceRayTracingPipelinePropertiesKHR &obj);
+void DumpVkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR &obj);
+void DumpVkPhysicalDeviceRobustness2FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceRobustness2FeaturesKHR &obj);
+void DumpVkPhysicalDeviceRobustness2PropertiesKHR(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceRobustness2PropertiesKHR &obj);
+void DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceSampleLocationsPropertiesEXT &obj);
+void DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceSamplerFilterMinmaxProperties &obj);
+void DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceSamplerYcbcrConversionFeatures &obj);
+void DumpVkPhysicalDeviceScalarBlockLayoutFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceScalarBlockLayoutFeatures &obj);
+void DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &obj);
+void DumpVkPhysicalDeviceShader64BitIndexingFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceShader64BitIndexingFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderAbortFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderAbortFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderAbortPropertiesKHR(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceShaderAbortPropertiesKHR &obj);
+void DumpVkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderAtomicFloatFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderAtomicInt64Features(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderAtomicInt64Features &obj);
+void DumpVkPhysicalDeviceShaderBfloat16FeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderBfloat16FeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderClockFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderClockFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderConstantDataFeaturesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceShaderConstantDataFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures &obj);
+void DumpVkPhysicalDeviceShaderDrawParametersFeatures(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderDrawParametersFeatures &obj);
+void DumpVkPhysicalDeviceShaderExpectAssumeFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceShaderExpectAssumeFeatures &obj);
+void DumpVkPhysicalDeviceShaderFloat16Int8Features(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderFloat16Int8Features &obj);
+void DumpVkPhysicalDeviceShaderFloat8FeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderFloat8FeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderFloatControls2Features(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderFloatControls2Features &obj);
+void DumpVkPhysicalDeviceShaderFmaFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderFmaFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceShaderIntegerDotProductFeatures &obj);
+void DumpVkPhysicalDeviceShaderIntegerDotProductProperties(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderIntegerDotProductProperties &obj);
+void DumpVkPhysicalDeviceShaderLongVectorFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceShaderLongVectorFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderLongVectorPropertiesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceShaderLongVectorPropertiesEXT &obj);
+void DumpVkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT &obj);
+void DumpVkPhysicalDeviceShaderObjectFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderObjectFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderObjectPropertiesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderObjectPropertiesEXT &obj);
+void DumpVkPhysicalDeviceShaderQuadControlFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderQuadControlFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &obj);
+void DumpVkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderSubgroupRotateFeatures &obj);
+void DumpVkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderTerminateInvocationFeatures &obj);
+void DumpVkPhysicalDeviceShaderTileImageFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceShaderTileImageFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderTileImagePropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderTileImagePropertiesEXT &obj);
+void DumpVkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderUntypedPointersFeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR &obj);
+void DumpVkPhysicalDeviceSparseProperties(Printer &p, std::string name, const VkPhysicalDeviceSparseProperties &obj);
+void DumpVkPhysicalDeviceSubgroupProperties(Printer &p, std::string name, const VkPhysicalDeviceSubgroupProperties &obj);
+void DumpVkPhysicalDeviceSubgroupSizeControlFeatures(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceSubgroupSizeControlFeatures &obj);
+void DumpVkPhysicalDeviceSubgroupSizeControlProperties(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceSubgroupSizeControlProperties &obj);
+void DumpVkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT &obj);
+void DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR &obj);
+void DumpVkPhysicalDeviceSynchronization2Features(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceSynchronization2Features &obj);
+void DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &obj);
+void DumpVkPhysicalDeviceTexelBufferAlignmentProperties(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceTexelBufferAlignmentProperties &obj);
+void DumpVkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT &obj);
+void DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceTextureCompressionASTCHDRFeatures &obj);
+void DumpVkPhysicalDeviceTimelineSemaphoreFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceTimelineSemaphoreFeatures &obj);
+void DumpVkPhysicalDeviceTimelineSemaphoreProperties(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceTimelineSemaphoreProperties &obj);
+void DumpVkPhysicalDeviceToolProperties(Printer &p, std::string name, const VkPhysicalDeviceToolProperties &obj);
+void DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceTransformFeedbackFeaturesEXT &obj);
+void DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceTransformFeedbackPropertiesEXT &obj);
+void DumpVkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR &obj);
+void DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures &obj);
+void DumpVkPhysicalDeviceVariablePointersFeatures(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceVariablePointersFeatures &obj);
+void DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceVertexAttributeDivisorFeatures &obj);
+void DumpVkPhysicalDeviceVertexAttributeDivisorProperties(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceVertexAttributeDivisorProperties &obj);
+void DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &obj);
+void DumpVkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT &obj);
+void DumpVkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &obj);
+void DumpVkPhysicalDeviceVideoDecodeVP9FeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR &obj);
+void DumpVkPhysicalDeviceVideoEncodeAV1FeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR &obj);
+void DumpVkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR &obj);
+void DumpVkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR &obj);
+void DumpVkPhysicalDeviceVideoMaintenance1FeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceVideoMaintenance1FeaturesKHR &obj);
+void DumpVkPhysicalDeviceVideoMaintenance2FeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceVideoMaintenance2FeaturesKHR &obj);
+void DumpVkPhysicalDeviceVulkan11Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan11Features &obj);
+void DumpVkPhysicalDeviceVulkan11Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan11Properties &obj);
+void DumpVkPhysicalDeviceVulkan12Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan12Features &obj);
+void DumpVkPhysicalDeviceVulkan12Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan12Properties &obj);
+void DumpVkPhysicalDeviceVulkan13Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan13Features &obj);
+void DumpVkPhysicalDeviceVulkan13Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan13Properties &obj);
+void DumpVkPhysicalDeviceVulkan14Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan14Features &obj);
+void DumpVkPhysicalDeviceVulkan14Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan14Properties &obj);
+void DumpVkPhysicalDeviceVulkanMemoryModelFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceVulkanMemoryModelFeatures &obj);
+void DumpVkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR &obj);
+void DumpVkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT &obj);
+void DumpVkPhysicalDeviceYcbcrImageArraysFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &obj);
+void DumpVkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT &obj);
+void DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures &obj);
+void DumpVkPresentTimingSurfaceCapabilitiesEXT(Printer &p, std::string name, const VkPresentTimingSurfaceCapabilitiesEXT &obj);
+void DumpVkQueueFamilyGlobalPriorityProperties(Printer &p, std::string name, const VkQueueFamilyGlobalPriorityProperties &obj);
+void DumpVkQueueFamilyOwnershipTransferPropertiesKHR(Printer &p, std::string name,
+                                                     const VkQueueFamilyOwnershipTransferPropertiesKHR &obj);
+void DumpVkQueueFamilyQueryResultStatusPropertiesKHR(Printer &p, std::string name,
+                                                     const VkQueueFamilyQueryResultStatusPropertiesKHR &obj);
+void DumpVkQueueFamilyVideoPropertiesKHR(Printer &p, std::string name, const VkQueueFamilyVideoPropertiesKHR &obj);
+void DumpVkSharedPresentSurfaceCapabilitiesKHR(Printer &p, std::string name, const VkSharedPresentSurfaceCapabilitiesKHR &obj);
+void DumpVkSubpassResolvePerformanceQueryEXT(Printer &p, std::string name, const VkSubpassResolvePerformanceQueryEXT &obj);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+void DumpVkSurfaceCapabilitiesFullScreenExclusiveEXT(Printer &p, std::string name,
+                                                     const VkSurfaceCapabilitiesFullScreenExclusiveEXT &obj);
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+void DumpVkSurfaceCapabilitiesKHR(Printer &p, std::string name, const VkSurfaceCapabilitiesKHR &obj);
+void DumpVkSurfaceCapabilitiesPresentId2KHR(Printer &p, std::string name, const VkSurfaceCapabilitiesPresentId2KHR &obj);
+void DumpVkSurfaceCapabilitiesPresentWait2KHR(Printer &p, std::string name, const VkSurfaceCapabilitiesPresentWait2KHR &obj);
+void DumpVkSurfaceFormatKHR(Printer &p, std::string name, const VkSurfaceFormatKHR &obj);
+void DumpVkSurfacePresentModeCompatibilityKHR(Printer &p, std::string name, const VkSurfacePresentModeCompatibilityKHR &obj);
+void DumpVkSurfacePresentScalingCapabilitiesKHR(Printer &p, std::string name, const VkSurfacePresentScalingCapabilitiesKHR &obj);
+void DumpVkSurfaceProtectedCapabilitiesKHR(Printer &p, std::string name, const VkSurfaceProtectedCapabilitiesKHR &obj);
+void DumpVkVideoCapabilitiesKHR(Printer &p, std::string name, const VkVideoCapabilitiesKHR &obj);
+void DumpVkVideoDecodeAV1CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeAV1CapabilitiesKHR &obj);
+void DumpVkVideoDecodeAV1ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeAV1ProfileInfoKHR &obj);
+void DumpVkVideoDecodeCapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeCapabilitiesKHR &obj);
+void DumpVkVideoDecodeH264CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeH264CapabilitiesKHR &obj);
+void DumpVkVideoDecodeH264ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeH264ProfileInfoKHR &obj);
+void DumpVkVideoDecodeH265CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeH265CapabilitiesKHR &obj);
+void DumpVkVideoDecodeH265ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeH265ProfileInfoKHR &obj);
+void DumpVkVideoDecodeUsageInfoKHR(Printer &p, std::string name, const VkVideoDecodeUsageInfoKHR &obj);
+void DumpVkVideoDecodeVP9CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeVP9CapabilitiesKHR &obj);
+void DumpVkVideoDecodeVP9ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeVP9ProfileInfoKHR &obj);
+void DumpVkVideoEncodeAV1CapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeAV1CapabilitiesKHR &obj);
+void DumpVkVideoEncodeAV1ProfileInfoKHR(Printer &p, std::string name, const VkVideoEncodeAV1ProfileInfoKHR &obj);
+void DumpVkVideoEncodeAV1QuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                        const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR &obj);
+void DumpVkVideoEncodeCapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeCapabilitiesKHR &obj);
+void DumpVkVideoEncodeH264CapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeH264CapabilitiesKHR &obj);
+void DumpVkVideoEncodeH264ProfileInfoKHR(Printer &p, std::string name, const VkVideoEncodeH264ProfileInfoKHR &obj);
+void DumpVkVideoEncodeH264QuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                         const VkVideoEncodeH264QuantizationMapCapabilitiesKHR &obj);
+void DumpVkVideoEncodeH265CapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeH265CapabilitiesKHR &obj);
+void DumpVkVideoEncodeH265ProfileInfoKHR(Printer &p, std::string name, const VkVideoEncodeH265ProfileInfoKHR &obj);
+void DumpVkVideoEncodeH265QuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                         const VkVideoEncodeH265QuantizationMapCapabilitiesKHR &obj);
+void DumpVkVideoEncodeIntraRefreshCapabilitiesKHR(Printer &p, std::string name,
+                                                  const VkVideoEncodeIntraRefreshCapabilitiesKHR &obj);
+void DumpVkVideoEncodeProfileRgbConversionInfoVALVE(Printer &p, std::string name,
+                                                    const VkVideoEncodeProfileRgbConversionInfoVALVE &obj);
+void DumpVkVideoEncodeQuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                     const VkVideoEncodeQuantizationMapCapabilitiesKHR &obj);
+void DumpVkVideoEncodeRgbConversionCapabilitiesVALVE(Printer &p, std::string name,
+                                                     const VkVideoEncodeRgbConversionCapabilitiesVALVE &obj);
+void DumpVkVideoEncodeUsageInfoKHR(Printer &p, std::string name, const VkVideoEncodeUsageInfoKHR &obj);
+void DumpVkVideoFormatAV1QuantizationMapPropertiesKHR(Printer &p, std::string name,
+                                                      const VkVideoFormatAV1QuantizationMapPropertiesKHR &obj);
+void DumpVkVideoFormatH265QuantizationMapPropertiesKHR(Printer &p, std::string name,
+                                                       const VkVideoFormatH265QuantizationMapPropertiesKHR &obj);
+void DumpVkVideoFormatPropertiesKHR(Printer &p, std::string name, const VkVideoFormatPropertiesKHR &obj);
+void DumpVkVideoFormatQuantizationMapPropertiesKHR(Printer &p, std::string name,
+                                                   const VkVideoFormatQuantizationMapPropertiesKHR &obj);
+void DumpVkVideoProfileInfoKHR(Printer &p, std::string name, const VkVideoProfileInfoKHR &obj);
+void DumpVkComponentMapping(Printer &p, std::string name, const VkComponentMapping &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkComponentSwizzle(p, "r", obj.r);
+    DumpVkComponentSwizzle(p, "g", obj.g);
+    DumpVkComponentSwizzle(p, "b", obj.b);
+    DumpVkComponentSwizzle(p, "a", obj.a);
+}
+void DumpVkConformanceVersion(Printer &p, std::string name, const VkConformanceVersion &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(8);
+    p.PrintKeyValue("major", static_cast<uint32_t>(obj.major));
+    p.PrintKeyValue("minor", static_cast<uint32_t>(obj.minor));
+    p.PrintKeyValue("subminor", static_cast<uint32_t>(obj.subminor));
+    p.PrintKeyValue("patch", static_cast<uint32_t>(obj.patch));
+}
+void DumpVkCooperativeMatrixPropertiesKHR(Printer &p, std::string name, const VkCooperativeMatrixPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    p.PrintKeyValue("MSize", obj.MSize);
+    p.PrintKeyValue("NSize", obj.NSize);
+    p.PrintKeyValue("KSize", obj.KSize);
+    DumpVkComponentTypeKHR(p, "AType", obj.AType);
+    DumpVkComponentTypeKHR(p, "BType", obj.BType);
+    DumpVkComponentTypeKHR(p, "CType", obj.CType);
+    DumpVkComponentTypeKHR(p, "ResultType", obj.ResultType);
+    p.PrintKeyBool("saturatingAccumulation", static_cast<bool>(obj.saturatingAccumulation));
+    DumpVkScopeKHR(p, "scope", obj.scope);
+}
+void DumpVkDisplayModeParametersKHR(Printer &p, std::string name, const VkDisplayModeParametersKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(11);
+    DumpVkExtent2D(p, "visibleRegion", obj.visibleRegion);
+    p.PrintKeyValue("refreshRate", obj.refreshRate);
+}
+void DumpVkDisplayModePropertiesKHR(Printer &p, std::string name, const VkDisplayModePropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkDisplayModeParametersKHR(p, "parameters", obj.parameters);
+}
+void DumpVkDisplayPlaneCapabilitiesKHR(Printer &p, std::string name, const VkDisplayPlaneCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkDisplayPlaneAlphaFlagsKHR(p, "supportedAlpha", obj.supportedAlpha);
+    DumpVkOffset2D(p, "minSrcPosition", obj.minSrcPosition);
+    DumpVkOffset2D(p, "maxSrcPosition", obj.maxSrcPosition);
+    DumpVkExtent2D(p, "minSrcExtent", obj.minSrcExtent);
+    DumpVkExtent2D(p, "maxSrcExtent", obj.maxSrcExtent);
+    DumpVkOffset2D(p, "minDstPosition", obj.minDstPosition);
+    DumpVkOffset2D(p, "maxDstPosition", obj.maxDstPosition);
+    DumpVkExtent2D(p, "minDstExtent", obj.minDstExtent);
+    DumpVkExtent2D(p, "maxDstExtent", obj.maxDstExtent);
+}
+void DumpVkDisplayPlanePropertiesKHR(Printer &p, std::string name, const VkDisplayPlanePropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyValue("currentStackIndex", obj.currentStackIndex);
+}
+void DumpVkDisplayPropertiesKHR(Printer &p, std::string name, const VkDisplayPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    if (obj.displayName == nullptr) {
+        p.PrintKeyString("displayName", "NULL");
+    } else {
+        p.PrintKeyString("displayName", obj.displayName);
+    }
+    DumpVkExtent2D(p, "physicalDimensions", obj.physicalDimensions);
+    DumpVkExtent2D(p, "physicalResolution", obj.physicalResolution);
+    DumpVkSurfaceTransformFlagsKHR(p, "supportedTransforms", obj.supportedTransforms);
+    p.PrintKeyBool("planeReorderPossible", static_cast<bool>(obj.planeReorderPossible));
+    p.PrintKeyBool("persistentContent", static_cast<bool>(obj.persistentContent));
+}
+void DumpVkDrmFormatModifierProperties2EXT(Printer &p, std::string name, const VkDrmFormatModifierProperties2EXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyValue("drmFormatModifier", obj.drmFormatModifier);
+    p.PrintKeyValue("drmFormatModifierPlaneCount", obj.drmFormatModifierPlaneCount);
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags2(p, "drmFormatModifierTilingFeatures", obj.drmFormatModifierTilingFeatures);
+}
+void DumpVkExtensionProperties(Printer &p, std::string name, const VkExtensionProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyString("extensionName", obj.extensionName);
+    p.PrintKeyValue("specVersion", obj.specVersion);
+}
+void DumpVkExtent2D(Printer &p, std::string name, const VkExtent2D &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(6);
+    p.PrintKeyValue("width", obj.width);
+    p.PrintKeyValue("height", obj.height);
+}
+void DumpVkExtent3D(Printer &p, std::string name, const VkExtent3D &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(6);
+    p.PrintKeyValue("width", obj.width);
+    p.PrintKeyValue("height", obj.height);
+    p.PrintKeyValue("depth", obj.depth);
+}
+void DumpVkFormatProperties(Printer &p, std::string name, const VkFormatProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags(p, "linearTilingFeatures", obj.linearTilingFeatures);
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags(p, "optimalTilingFeatures", obj.optimalTilingFeatures);
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags(p, "bufferFeatures", obj.bufferFeatures);
+}
+void DumpVkFormatProperties3(Printer &p, std::string name, const VkFormatProperties3 &obj) {
+    ObjectWrapper object{p, name};
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags2(p, "linearTilingFeatures", obj.linearTilingFeatures);
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags2(p, "optimalTilingFeatures", obj.optimalTilingFeatures);
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags2(p, "bufferFeatures", obj.bufferFeatures);
+}
+void DumpVkLayerProperties(Printer &p, std::string name, const VkLayerProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyString("layerName", obj.layerName);
+    p.PrintKeyValue("specVersion", obj.specVersion);
+    p.PrintKeyValue("implementationVersion", obj.implementationVersion);
+    p.PrintKeyString("description", obj.description);
+}
+void DumpVkMultisamplePropertiesEXT(Printer &p, std::string name, const VkMultisamplePropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkExtent2D(p, "maxSampleLocationGridSize", obj.maxSampleLocationGridSize);
+}
+void DumpVkOffset2D(Printer &p, std::string name, const VkOffset2D &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(1);
+    p.PrintKeyValue("x", obj.x);
+    p.PrintKeyValue("y", obj.y);
+}
+void DumpVkPhysicalDevice16BitStorageFeatures(Printer &p, std::string name, const VkPhysicalDevice16BitStorageFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("storageBuffer16BitAccess", static_cast<bool>(obj.storageBuffer16BitAccess));
+    p.PrintKeyBool("uniformAndStorageBuffer16BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer16BitAccess));
+    p.PrintKeyBool("storagePushConstant16", static_cast<bool>(obj.storagePushConstant16));
+    p.PrintKeyBool("storageInputOutput16", static_cast<bool>(obj.storageInputOutput16));
+}
+void DumpVkPhysicalDevice4444FormatsFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevice4444FormatsFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyBool("formatA4R4G4B4", static_cast<bool>(obj.formatA4R4G4B4));
+    p.PrintKeyBool("formatA4B4G4R4", static_cast<bool>(obj.formatA4B4G4R4));
+}
+void DumpVkPhysicalDevice8BitStorageFeatures(Printer &p, std::string name, const VkPhysicalDevice8BitStorageFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyBool("storageBuffer8BitAccess", static_cast<bool>(obj.storageBuffer8BitAccess));
+    p.PrintKeyBool("uniformAndStorageBuffer8BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer8BitAccess));
+    p.PrintKeyBool("storagePushConstant8", static_cast<bool>(obj.storagePushConstant8));
+}
+void DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceASTCDecodeFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(24);
+    p.PrintKeyBool("decodeModeSharedExponent", static_cast<bool>(obj.decodeModeSharedExponent));
+}
+void DumpVkPhysicalDeviceAccelerationStructureFeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceAccelerationStructureFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(53);
+    p.PrintKeyBool("accelerationStructure", static_cast<bool>(obj.accelerationStructure));
+    p.PrintKeyBool("accelerationStructureCaptureReplay", static_cast<bool>(obj.accelerationStructureCaptureReplay));
+    p.PrintKeyBool("accelerationStructureIndirectBuild", static_cast<bool>(obj.accelerationStructureIndirectBuild));
+    p.PrintKeyBool("accelerationStructureHostCommands", static_cast<bool>(obj.accelerationStructureHostCommands));
+    p.PrintKeyBool("descriptorBindingAccelerationStructureUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingAccelerationStructureUpdateAfterBind));
+}
+void DumpVkPhysicalDeviceAccelerationStructurePropertiesKHR(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceAccelerationStructurePropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(58);
+    p.PrintKeyValue("maxGeometryCount", obj.maxGeometryCount);
+    p.PrintKeyValue("maxInstanceCount", obj.maxInstanceCount);
+    p.PrintKeyValue("maxPrimitiveCount", obj.maxPrimitiveCount);
+    p.PrintKeyValue("maxPerStageDescriptorAccelerationStructures", obj.maxPerStageDescriptorAccelerationStructures);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindAccelerationStructures",
+                    obj.maxPerStageDescriptorUpdateAfterBindAccelerationStructures);
+    p.PrintKeyValue("maxDescriptorSetAccelerationStructures", obj.maxDescriptorSetAccelerationStructures);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindAccelerationStructures",
+                    obj.maxDescriptorSetUpdateAfterBindAccelerationStructures);
+    p.PrintKeyValue("minAccelerationStructureScratchOffsetAlignment", obj.minAccelerationStructureScratchOffsetAlignment);
+}
+void DumpVkPhysicalDeviceAddressBindingReportFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceAddressBindingReportFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("reportAddressBinding", static_cast<bool>(obj.reportAddressBinding));
+}
+void DumpVkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("attachmentFeedbackLoopDynamicState", static_cast<bool>(obj.attachmentFeedbackLoopDynamicState));
+}
+void DumpVkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("attachmentFeedbackLoopLayout", static_cast<bool>(obj.attachmentFeedbackLoopLayout));
+}
+void DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(31);
+    p.PrintKeyBool("advancedBlendCoherentOperations", static_cast<bool>(obj.advancedBlendCoherentOperations));
+}
+void DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(37);
+    p.PrintKeyValue("advancedBlendMaxColorAttachments", obj.advancedBlendMaxColorAttachments);
+    p.PrintKeyBool("advancedBlendIndependentBlend", static_cast<bool>(obj.advancedBlendIndependentBlend));
+    p.PrintKeyBool("advancedBlendNonPremultipliedSrcColor", static_cast<bool>(obj.advancedBlendNonPremultipliedSrcColor));
+    p.PrintKeyBool("advancedBlendNonPremultipliedDstColor", static_cast<bool>(obj.advancedBlendNonPremultipliedDstColor));
+    p.PrintKeyBool("advancedBlendCorrelatedOverlap", static_cast<bool>(obj.advancedBlendCorrelatedOverlap));
+    p.PrintKeyBool("advancedBlendAllOperations", static_cast<bool>(obj.advancedBlendAllOperations));
+}
+void DumpVkPhysicalDeviceBorderColorSwizzleFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("borderColorSwizzle", static_cast<bool>(obj.borderColorSwizzle));
+    p.PrintKeyBool("borderColorSwizzleFromImage", static_cast<bool>(obj.borderColorSwizzleFromImage));
+}
+void DumpVkPhysicalDeviceBufferDeviceAddressFeatures(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceBufferDeviceAddressFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress));
+    p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay));
+    p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice));
+}
+void DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress));
+    p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay));
+    p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice));
+}
+void DumpVkPhysicalDeviceColorWriteEnableFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceColorWriteEnableFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("colorWriteEnable", static_cast<bool>(obj.colorWriteEnable));
+}
+void DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("computeDerivativeGroupQuads", static_cast<bool>(obj.computeDerivativeGroupQuads));
+    p.PrintKeyBool("computeDerivativeGroupLinear", static_cast<bool>(obj.computeDerivativeGroupLinear));
+}
+void DumpVkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("meshAndTaskShaderDerivatives", static_cast<bool>(obj.meshAndTaskShaderDerivatives));
+}
+void DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceConditionalRenderingFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("conditionalRendering", static_cast<bool>(obj.conditionalRendering));
+    p.PrintKeyBool("inheritedConditionalRendering", static_cast<bool>(obj.inheritedConditionalRendering));
+}
+void DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceConservativeRasterizationPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(43);
+    p.PrintKeyValue("primitiveOverestimationSize", obj.primitiveOverestimationSize);
+    p.PrintKeyValue("maxExtraPrimitiveOverestimationSize", obj.maxExtraPrimitiveOverestimationSize);
+    p.PrintKeyValue("extraPrimitiveOverestimationSizeGranularity", obj.extraPrimitiveOverestimationSizeGranularity);
+    p.PrintKeyBool("primitiveUnderestimation", static_cast<bool>(obj.primitiveUnderestimation));
+    p.PrintKeyBool("conservativePointAndLineRasterization", static_cast<bool>(obj.conservativePointAndLineRasterization));
+    p.PrintKeyBool("degenerateTrianglesRasterized", static_cast<bool>(obj.degenerateTrianglesRasterized));
+    p.PrintKeyBool("degenerateLinesRasterized", static_cast<bool>(obj.degenerateLinesRasterized));
+    p.PrintKeyBool("fullyCoveredFragmentShaderInputVariable", static_cast<bool>(obj.fullyCoveredFragmentShaderInputVariable));
+    p.PrintKeyBool("conservativeRasterizationPostDepthCoverage", static_cast<bool>(obj.conservativeRasterizationPostDepthCoverage));
+}
+void DumpVkPhysicalDeviceCooperativeMatrixFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceCooperativeMatrixFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(35);
+    p.PrintKeyBool("cooperativeMatrix", static_cast<bool>(obj.cooperativeMatrix));
+    p.PrintKeyBool("cooperativeMatrixRobustBufferAccess", static_cast<bool>(obj.cooperativeMatrixRobustBufferAccess));
+}
+void DumpVkPhysicalDeviceCooperativeMatrixPropertiesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceCooperativeMatrixPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkShaderStageFlags(p, "cooperativeMatrixSupportedStages", obj.cooperativeMatrixSupportedStages);
+}
+void DumpVkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("indirectMemoryCopy", static_cast<bool>(obj.indirectMemoryCopy));
+    p.PrintKeyBool("indirectMemoryToImageCopy", static_cast<bool>(obj.indirectMemoryToImageCopy));
+}
+void DumpVkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkQueueFlags(p, "supportedQueues", obj.supportedQueues);
+}
+void DumpVkPhysicalDeviceCustomBorderColorFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceCustomBorderColorFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(30);
+    p.PrintKeyBool("customBorderColors", static_cast<bool>(obj.customBorderColors));
+    p.PrintKeyBool("customBorderColorWithoutFormat", static_cast<bool>(obj.customBorderColorWithoutFormat));
+}
+void DumpVkPhysicalDeviceCustomBorderColorPropertiesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceCustomBorderColorPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyValue("maxCustomBorderColorSamplers", obj.maxCustomBorderColorSamplers);
+}
+void DumpVkPhysicalDeviceCustomResolveFeaturesEXT(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceCustomResolveFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyBool("customResolve", static_cast<bool>(obj.customResolve));
+}
+void DumpVkPhysicalDeviceDepthBiasControlFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDepthBiasControlFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(47);
+    p.PrintKeyBool("depthBiasControl", static_cast<bool>(obj.depthBiasControl));
+    p.PrintKeyBool("leastRepresentableValueForceUnormRepresentation",
+                   static_cast<bool>(obj.leastRepresentableValueForceUnormRepresentation));
+    p.PrintKeyBool("floatRepresentation", static_cast<bool>(obj.floatRepresentation));
+    p.PrintKeyBool("depthBiasExact", static_cast<bool>(obj.depthBiasExact));
+}
+void DumpVkPhysicalDeviceDepthClampControlFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceDepthClampControlFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("depthClampControl", static_cast<bool>(obj.depthClampControl));
+}
+void DumpVkPhysicalDeviceDepthClampZeroOneFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("depthClampZeroOne", static_cast<bool>(obj.depthClampZeroOne));
+}
+void DumpVkPhysicalDeviceDepthClipControlFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDepthClipControlFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("depthClipControl", static_cast<bool>(obj.depthClipControl));
+}
+void DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceDepthClipEnableFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(15);
+    p.PrintKeyBool("depthClipEnable", static_cast<bool>(obj.depthClipEnable));
+}
+void DumpVkPhysicalDeviceDepthStencilResolveProperties(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDepthStencilResolveProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    DumpVkResolveModeFlags(p, "supportedDepthResolveModes", obj.supportedDepthResolveModes);
+    DumpVkResolveModeFlags(p, "supportedStencilResolveModes", obj.supportedStencilResolveModes);
+    p.PrintKeyBool("independentResolveNone", static_cast<bool>(obj.independentResolveNone));
+    p.PrintKeyBool("independentResolve", static_cast<bool>(obj.independentResolve));
+}
+void DumpVkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(44);
+    p.PrintKeyValue("combinedImageSamplerDensityMapDescriptorSize", obj.combinedImageSamplerDensityMapDescriptorSize);
+}
+void DumpVkPhysicalDeviceDescriptorBufferFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDescriptorBufferFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("descriptorBuffer", static_cast<bool>(obj.descriptorBuffer));
+    p.PrintKeyBool("descriptorBufferCaptureReplay", static_cast<bool>(obj.descriptorBufferCaptureReplay));
+    p.PrintKeyBool("descriptorBufferImageLayoutIgnored", static_cast<bool>(obj.descriptorBufferImageLayoutIgnored));
+    p.PrintKeyBool("descriptorBufferPushDescriptors", static_cast<bool>(obj.descriptorBufferPushDescriptors));
+}
+void DumpVkPhysicalDeviceDescriptorBufferPropertiesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDescriptorBufferPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(52);
+    p.PrintKeyBool("combinedImageSamplerDescriptorSingleArray", static_cast<bool>(obj.combinedImageSamplerDescriptorSingleArray));
+    p.PrintKeyBool("bufferlessPushDescriptors", static_cast<bool>(obj.bufferlessPushDescriptors));
+    p.PrintKeyBool("allowSamplerImageViewPostSubmitCreation", static_cast<bool>(obj.allowSamplerImageViewPostSubmitCreation));
+    p.PrintKeyValue("descriptorBufferOffsetAlignment", to_hex_str(p, obj.descriptorBufferOffsetAlignment));
+    p.PrintKeyValue("maxDescriptorBufferBindings", obj.maxDescriptorBufferBindings);
+    p.PrintKeyValue("maxResourceDescriptorBufferBindings", obj.maxResourceDescriptorBufferBindings);
+    p.PrintKeyValue("maxSamplerDescriptorBufferBindings", obj.maxSamplerDescriptorBufferBindings);
+    p.PrintKeyValue("maxEmbeddedImmutableSamplerBindings", obj.maxEmbeddedImmutableSamplerBindings);
+    p.PrintKeyValue("maxEmbeddedImmutableSamplers", obj.maxEmbeddedImmutableSamplers);
+    p.PrintKeyValue("bufferCaptureReplayDescriptorDataSize", obj.bufferCaptureReplayDescriptorDataSize);
+    p.PrintKeyValue("imageCaptureReplayDescriptorDataSize", obj.imageCaptureReplayDescriptorDataSize);
+    p.PrintKeyValue("imageViewCaptureReplayDescriptorDataSize", obj.imageViewCaptureReplayDescriptorDataSize);
+    p.PrintKeyValue("samplerCaptureReplayDescriptorDataSize", obj.samplerCaptureReplayDescriptorDataSize);
+    p.PrintKeyValue("accelerationStructureCaptureReplayDescriptorDataSize",
+                    obj.accelerationStructureCaptureReplayDescriptorDataSize);
+    p.PrintKeyValue("samplerDescriptorSize", obj.samplerDescriptorSize);
+    p.PrintKeyValue("combinedImageSamplerDescriptorSize", obj.combinedImageSamplerDescriptorSize);
+    p.PrintKeyValue("sampledImageDescriptorSize", obj.sampledImageDescriptorSize);
+    p.PrintKeyValue("storageImageDescriptorSize", obj.storageImageDescriptorSize);
+    p.PrintKeyValue("uniformTexelBufferDescriptorSize", obj.uniformTexelBufferDescriptorSize);
+    p.PrintKeyValue("robustUniformTexelBufferDescriptorSize", obj.robustUniformTexelBufferDescriptorSize);
+    p.PrintKeyValue("storageTexelBufferDescriptorSize", obj.storageTexelBufferDescriptorSize);
+    p.PrintKeyValue("robustStorageTexelBufferDescriptorSize", obj.robustStorageTexelBufferDescriptorSize);
+    p.PrintKeyValue("uniformBufferDescriptorSize", obj.uniformBufferDescriptorSize);
+    p.PrintKeyValue("robustUniformBufferDescriptorSize", obj.robustUniformBufferDescriptorSize);
+    p.PrintKeyValue("storageBufferDescriptorSize", obj.storageBufferDescriptorSize);
+    p.PrintKeyValue("robustStorageBufferDescriptorSize", obj.robustStorageBufferDescriptorSize);
+    p.PrintKeyValue("inputAttachmentDescriptorSize", obj.inputAttachmentDescriptorSize);
+    p.PrintKeyValue("accelerationStructureDescriptorSize", obj.accelerationStructureDescriptorSize);
+    p.PrintKeyValue("maxSamplerDescriptorBufferRange", to_hex_str(p, obj.maxSamplerDescriptorBufferRange));
+    p.PrintKeyValue("maxResourceDescriptorBufferRange", to_hex_str(p, obj.maxResourceDescriptorBufferRange));
+    p.PrintKeyValue("samplerDescriptorBufferAddressSpaceSize", to_hex_str(p, obj.samplerDescriptorBufferAddressSpaceSize));
+    p.PrintKeyValue("resourceDescriptorBufferAddressSpaceSize", to_hex_str(p, obj.resourceDescriptorBufferAddressSpaceSize));
+    p.PrintKeyValue("descriptorBufferAddressSpaceSize", to_hex_str(p, obj.descriptorBufferAddressSpaceSize));
+}
+void DumpVkPhysicalDeviceDescriptorHeapFeaturesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceDescriptorHeapFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("descriptorHeap", static_cast<bool>(obj.descriptorHeap));
+    p.PrintKeyBool("descriptorHeapCaptureReplay", static_cast<bool>(obj.descriptorHeapCaptureReplay));
+}
+void DumpVkPhysicalDeviceDescriptorHeapPropertiesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDescriptorHeapPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(39);
+    p.PrintKeyValue("samplerHeapAlignment", to_hex_str(p, obj.samplerHeapAlignment));
+    p.PrintKeyValue("resourceHeapAlignment", to_hex_str(p, obj.resourceHeapAlignment));
+    p.PrintKeyValue("maxSamplerHeapSize", to_hex_str(p, obj.maxSamplerHeapSize));
+    p.PrintKeyValue("maxResourceHeapSize", to_hex_str(p, obj.maxResourceHeapSize));
+    p.PrintKeyValue("minSamplerHeapReservedRange", to_hex_str(p, obj.minSamplerHeapReservedRange));
+    p.PrintKeyValue("minSamplerHeapReservedRangeWithEmbedded", to_hex_str(p, obj.minSamplerHeapReservedRangeWithEmbedded));
+    p.PrintKeyValue("minResourceHeapReservedRange", to_hex_str(p, obj.minResourceHeapReservedRange));
+    p.PrintKeyValue("samplerDescriptorSize", to_hex_str(p, obj.samplerDescriptorSize));
+    p.PrintKeyValue("imageDescriptorSize", to_hex_str(p, obj.imageDescriptorSize));
+    p.PrintKeyValue("bufferDescriptorSize", to_hex_str(p, obj.bufferDescriptorSize));
+    p.PrintKeyValue("samplerDescriptorAlignment", to_hex_str(p, obj.samplerDescriptorAlignment));
+    p.PrintKeyValue("imageDescriptorAlignment", to_hex_str(p, obj.imageDescriptorAlignment));
+    p.PrintKeyValue("bufferDescriptorAlignment", to_hex_str(p, obj.bufferDescriptorAlignment));
+    p.PrintKeyValue("maxPushDataSize", to_hex_str(p, obj.maxPushDataSize));
+    p.PrintKeyValue("imageCaptureReplayOpaqueDataSize", obj.imageCaptureReplayOpaqueDataSize);
+    p.PrintKeyValue("maxDescriptorHeapEmbeddedSamplers", obj.maxDescriptorHeapEmbeddedSamplers);
+    p.PrintKeyValue("samplerYcbcrConversionCount", obj.samplerYcbcrConversionCount);
+    p.PrintKeyBool("sparseDescriptorHeaps", static_cast<bool>(obj.sparseDescriptorHeaps));
+    p.PrintKeyBool("protectedDescriptorHeaps", static_cast<bool>(obj.protectedDescriptorHeaps));
+}
+void DumpVkPhysicalDeviceDescriptorHeapTensorPropertiesARM(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyValue("tensorDescriptorSize", to_hex_str(p, obj.tensorDescriptorSize));
+    p.PrintKeyValue("tensorDescriptorAlignment", to_hex_str(p, obj.tensorDescriptorAlignment));
+    p.PrintKeyValue("tensorCaptureReplayOpaqueDataSize", obj.tensorCaptureReplayOpaqueDataSize);
+}
+void DumpVkPhysicalDeviceDescriptorIndexingFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceDescriptorIndexingFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(50);
+    p.PrintKeyBool("shaderInputAttachmentArrayDynamicIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayDynamicIndexing));
+    p.PrintKeyBool("shaderUniformTexelBufferArrayDynamicIndexing",
+                   static_cast<bool>(obj.shaderUniformTexelBufferArrayDynamicIndexing));
+    p.PrintKeyBool("shaderStorageTexelBufferArrayDynamicIndexing",
+                   static_cast<bool>(obj.shaderStorageTexelBufferArrayDynamicIndexing));
+    p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexing",
+                   static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderUniformTexelBufferArrayNonUniformIndexing",
+                   static_cast<bool>(obj.shaderUniformTexelBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderStorageTexelBufferArrayNonUniformIndexing",
+                   static_cast<bool>(obj.shaderStorageTexelBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("descriptorBindingUniformBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingUniformBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingSampledImageUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingSampledImageUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingStorageImageUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingStorageImageUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingStorageBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingStorageBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingUniformTexelBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingUniformTexelBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingStorageTexelBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingStorageTexelBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingUpdateUnusedWhilePending", static_cast<bool>(obj.descriptorBindingUpdateUnusedWhilePending));
+    p.PrintKeyBool("descriptorBindingPartiallyBound", static_cast<bool>(obj.descriptorBindingPartiallyBound));
+    p.PrintKeyBool("descriptorBindingVariableDescriptorCount", static_cast<bool>(obj.descriptorBindingVariableDescriptorCount));
+    p.PrintKeyBool("runtimeDescriptorArray", static_cast<bool>(obj.runtimeDescriptorArray));
+}
+void DumpVkPhysicalDeviceDescriptorIndexingProperties(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceDescriptorIndexingProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(52);
+    p.PrintKeyValue("maxUpdateAfterBindDescriptorsInAllPools", obj.maxUpdateAfterBindDescriptorsInAllPools);
+    p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexingNative));
+    p.PrintKeyBool("robustBufferAccessUpdateAfterBind", static_cast<bool>(obj.robustBufferAccessUpdateAfterBind));
+    p.PrintKeyBool("quadDivergentImplicitLod", static_cast<bool>(obj.quadDivergentImplicitLod));
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSamplers", obj.maxPerStageDescriptorUpdateAfterBindSamplers);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindUniformBuffers", obj.maxPerStageDescriptorUpdateAfterBindUniformBuffers);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageBuffers", obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSampledImages", obj.maxPerStageDescriptorUpdateAfterBindSampledImages);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageImages", obj.maxPerStageDescriptorUpdateAfterBindStorageImages);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInputAttachments",
+                    obj.maxPerStageDescriptorUpdateAfterBindInputAttachments);
+    p.PrintKeyValue("maxPerStageUpdateAfterBindResources", obj.maxPerStageUpdateAfterBindResources);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSamplers", obj.maxDescriptorSetUpdateAfterBindSamplers);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffers", obj.maxDescriptorSetUpdateAfterBindUniformBuffers);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffersDynamic",
+                    obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffers", obj.maxDescriptorSetUpdateAfterBindStorageBuffers);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffersDynamic",
+                    obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSampledImages", obj.maxDescriptorSetUpdateAfterBindSampledImages);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageImages", obj.maxDescriptorSetUpdateAfterBindStorageImages);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInputAttachments", obj.maxDescriptorSetUpdateAfterBindInputAttachments);
+}
+void DumpVkPhysicalDeviceDeviceAddressCommandsFeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("deviceAddressCommands", static_cast<bool>(obj.deviceAddressCommands));
+}
+void DumpVkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(30);
+    p.PrintKeyBool("deviceGeneratedCommands", static_cast<bool>(obj.deviceGeneratedCommands));
+    p.PrintKeyBool("dynamicGeneratedPipelineLayout", static_cast<bool>(obj.dynamicGeneratedPipelineLayout));
+}
+void DumpVkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(45);
+    p.PrintKeyValue("maxIndirectPipelineCount", obj.maxIndirectPipelineCount);
+    p.PrintKeyValue("maxIndirectShaderObjectCount", obj.maxIndirectShaderObjectCount);
+    p.PrintKeyValue("maxIndirectSequenceCount", obj.maxIndirectSequenceCount);
+    p.PrintKeyValue("maxIndirectCommandsTokenCount", obj.maxIndirectCommandsTokenCount);
+    p.PrintKeyValue("maxIndirectCommandsTokenOffset", obj.maxIndirectCommandsTokenOffset);
+    p.PrintKeyValue("maxIndirectCommandsIndirectStride", obj.maxIndirectCommandsIndirectStride);
+    DumpVkIndirectCommandsInputModeFlagsEXT(p, "supportedIndirectCommandsInputModes", obj.supportedIndirectCommandsInputModes);
+    DumpVkShaderStageFlags(p, "supportedIndirectCommandsShaderStages", obj.supportedIndirectCommandsShaderStages);
+    DumpVkShaderStageFlags(p, "supportedIndirectCommandsShaderStagesPipelineBinding",
+                           obj.supportedIndirectCommandsShaderStagesPipelineBinding);
+    DumpVkShaderStageFlags(p, "supportedIndirectCommandsShaderStagesShaderBinding",
+                           obj.supportedIndirectCommandsShaderStagesShaderBinding);
+    p.PrintKeyBool("deviceGeneratedCommandsTransformFeedback", static_cast<bool>(obj.deviceGeneratedCommandsTransformFeedback));
+    p.PrintKeyBool("deviceGeneratedCommandsMultiDrawIndirectCount",
+                   static_cast<bool>(obj.deviceGeneratedCommandsMultiDrawIndirectCount));
+}
+void DumpVkPhysicalDeviceDeviceMemoryReportFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(18);
+    p.PrintKeyBool("deviceMemoryReport", static_cast<bool>(obj.deviceMemoryReport));
+}
+void DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDiscardRectanglePropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyValue("maxDiscardRectangles", obj.maxDiscardRectangles);
+}
+void DumpVkPhysicalDeviceDriverProperties(Printer &p, std::string name, const VkPhysicalDeviceDriverProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(10);
+    DumpVkDriverId(p, "driverID", obj.driverID);
+    p.PrintKeyString("driverName", obj.driverName);
+    p.PrintKeyString("driverInfo", obj.driverInfo);
+    DumpVkConformanceVersion(p, "conformanceVersion", obj.conformanceVersion);
+}
+void DumpVkPhysicalDeviceDrmPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceDrmPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("hasPrimary", static_cast<bool>(obj.hasPrimary));
+    p.PrintKeyBool("hasRender", static_cast<bool>(obj.hasRender));
+    p.PrintKeyValue("primaryMajor", obj.primaryMajor);
+    p.PrintKeyValue("primaryMinor", obj.primaryMinor);
+    p.PrintKeyValue("renderMajor", obj.renderMajor);
+    p.PrintKeyValue("renderMinor", obj.renderMinor);
+}
+void DumpVkPhysicalDeviceDynamicRenderingFeatures(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceDynamicRenderingFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("dynamicRendering", static_cast<bool>(obj.dynamicRendering));
+}
+void DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceDynamicRenderingLocalReadFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("dynamicRenderingLocalRead", static_cast<bool>(obj.dynamicRenderingLocalRead));
+}
+void DumpVkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyBool("dynamicRenderingUnusedAttachments", static_cast<bool>(obj.dynamicRenderingUnusedAttachments));
+}
+void DumpVkPhysicalDeviceExtendedDynamicState2FeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(39);
+    p.PrintKeyBool("extendedDynamicState2", static_cast<bool>(obj.extendedDynamicState2));
+    p.PrintKeyBool("extendedDynamicState2LogicOp", static_cast<bool>(obj.extendedDynamicState2LogicOp));
+    p.PrintKeyBool("extendedDynamicState2PatchControlPoints", static_cast<bool>(obj.extendedDynamicState2PatchControlPoints));
+}
+void DumpVkPhysicalDeviceExtendedDynamicState3FeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(53);
+    p.PrintKeyBool("extendedDynamicState3TessellationDomainOrigin",
+                   static_cast<bool>(obj.extendedDynamicState3TessellationDomainOrigin));
+    p.PrintKeyBool("extendedDynamicState3DepthClampEnable", static_cast<bool>(obj.extendedDynamicState3DepthClampEnable));
+    p.PrintKeyBool("extendedDynamicState3PolygonMode", static_cast<bool>(obj.extendedDynamicState3PolygonMode));
+    p.PrintKeyBool("extendedDynamicState3RasterizationSamples", static_cast<bool>(obj.extendedDynamicState3RasterizationSamples));
+    p.PrintKeyBool("extendedDynamicState3SampleMask", static_cast<bool>(obj.extendedDynamicState3SampleMask));
+    p.PrintKeyBool("extendedDynamicState3AlphaToCoverageEnable", static_cast<bool>(obj.extendedDynamicState3AlphaToCoverageEnable));
+    p.PrintKeyBool("extendedDynamicState3AlphaToOneEnable", static_cast<bool>(obj.extendedDynamicState3AlphaToOneEnable));
+    p.PrintKeyBool("extendedDynamicState3LogicOpEnable", static_cast<bool>(obj.extendedDynamicState3LogicOpEnable));
+    p.PrintKeyBool("extendedDynamicState3ColorBlendEnable", static_cast<bool>(obj.extendedDynamicState3ColorBlendEnable));
+    p.PrintKeyBool("extendedDynamicState3ColorBlendEquation", static_cast<bool>(obj.extendedDynamicState3ColorBlendEquation));
+    p.PrintKeyBool("extendedDynamicState3ColorWriteMask", static_cast<bool>(obj.extendedDynamicState3ColorWriteMask));
+    p.PrintKeyBool("extendedDynamicState3RasterizationStream", static_cast<bool>(obj.extendedDynamicState3RasterizationStream));
+    p.PrintKeyBool("extendedDynamicState3ConservativeRasterizationMode",
+                   static_cast<bool>(obj.extendedDynamicState3ConservativeRasterizationMode));
+    p.PrintKeyBool("extendedDynamicState3ExtraPrimitiveOverestimationSize",
+                   static_cast<bool>(obj.extendedDynamicState3ExtraPrimitiveOverestimationSize));
+    p.PrintKeyBool("extendedDynamicState3DepthClipEnable", static_cast<bool>(obj.extendedDynamicState3DepthClipEnable));
+    p.PrintKeyBool("extendedDynamicState3SampleLocationsEnable", static_cast<bool>(obj.extendedDynamicState3SampleLocationsEnable));
+    p.PrintKeyBool("extendedDynamicState3ColorBlendAdvanced", static_cast<bool>(obj.extendedDynamicState3ColorBlendAdvanced));
+    p.PrintKeyBool("extendedDynamicState3ProvokingVertexMode", static_cast<bool>(obj.extendedDynamicState3ProvokingVertexMode));
+    p.PrintKeyBool("extendedDynamicState3LineRasterizationMode", static_cast<bool>(obj.extendedDynamicState3LineRasterizationMode));
+    p.PrintKeyBool("extendedDynamicState3LineStippleEnable", static_cast<bool>(obj.extendedDynamicState3LineStippleEnable));
+    p.PrintKeyBool("extendedDynamicState3DepthClipNegativeOneToOne",
+                   static_cast<bool>(obj.extendedDynamicState3DepthClipNegativeOneToOne));
+    p.PrintKeyBool("extendedDynamicState3ViewportWScalingEnable",
+                   static_cast<bool>(obj.extendedDynamicState3ViewportWScalingEnable));
+    p.PrintKeyBool("extendedDynamicState3ViewportSwizzle", static_cast<bool>(obj.extendedDynamicState3ViewportSwizzle));
+    p.PrintKeyBool("extendedDynamicState3CoverageToColorEnable", static_cast<bool>(obj.extendedDynamicState3CoverageToColorEnable));
+    p.PrintKeyBool("extendedDynamicState3CoverageToColorLocation",
+                   static_cast<bool>(obj.extendedDynamicState3CoverageToColorLocation));
+    p.PrintKeyBool("extendedDynamicState3CoverageModulationMode",
+                   static_cast<bool>(obj.extendedDynamicState3CoverageModulationMode));
+    p.PrintKeyBool("extendedDynamicState3CoverageModulationTableEnable",
+                   static_cast<bool>(obj.extendedDynamicState3CoverageModulationTableEnable));
+    p.PrintKeyBool("extendedDynamicState3CoverageModulationTable",
+                   static_cast<bool>(obj.extendedDynamicState3CoverageModulationTable));
+    p.PrintKeyBool("extendedDynamicState3CoverageReductionMode", static_cast<bool>(obj.extendedDynamicState3CoverageReductionMode));
+    p.PrintKeyBool("extendedDynamicState3RepresentativeFragmentTestEnable",
+                   static_cast<bool>(obj.extendedDynamicState3RepresentativeFragmentTestEnable));
+    p.PrintKeyBool("extendedDynamicState3ShadingRateImageEnable",
+                   static_cast<bool>(obj.extendedDynamicState3ShadingRateImageEnable));
+}
+void DumpVkPhysicalDeviceExtendedDynamicState3PropertiesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(36);
+    p.PrintKeyBool("dynamicPrimitiveTopologyUnrestricted", static_cast<bool>(obj.dynamicPrimitiveTopologyUnrestricted));
+}
+void DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("extendedDynamicState", static_cast<bool>(obj.extendedDynamicState));
+}
+void DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceExternalMemoryHostPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(31);
+    p.PrintKeyValue("minImportedHostPointerAlignment", to_hex_str(p, obj.minImportedHostPointerAlignment));
+}
+void DumpVkPhysicalDeviceFaultFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceFaultFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("deviceFault", static_cast<bool>(obj.deviceFault));
+    p.PrintKeyBool("deviceFaultVendorBinary", static_cast<bool>(obj.deviceFaultVendorBinary));
+}
+void DumpVkPhysicalDeviceFaultFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceFaultFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("deviceFault", static_cast<bool>(obj.deviceFault));
+    p.PrintKeyBool("deviceFaultVendorBinary", static_cast<bool>(obj.deviceFaultVendorBinary));
+    p.PrintKeyBool("deviceFaultReportMasked", static_cast<bool>(obj.deviceFaultReportMasked));
+    p.PrintKeyBool("deviceFaultDeviceLostOnMasked", static_cast<bool>(obj.deviceFaultDeviceLostOnMasked));
+}
+void DumpVkPhysicalDeviceFaultPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceFaultPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyValue("maxDeviceFaultCount", obj.maxDeviceFaultCount);
+}
+void DumpVkPhysicalDeviceFeatures(Printer &p, std::string name, const VkPhysicalDeviceFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(39);
+    p.PrintKeyBool("robustBufferAccess", static_cast<bool>(obj.robustBufferAccess));
+    p.PrintKeyBool("fullDrawIndexUint32", static_cast<bool>(obj.fullDrawIndexUint32));
+    p.PrintKeyBool("imageCubeArray", static_cast<bool>(obj.imageCubeArray));
+    p.PrintKeyBool("independentBlend", static_cast<bool>(obj.independentBlend));
+    p.PrintKeyBool("geometryShader", static_cast<bool>(obj.geometryShader));
+    p.PrintKeyBool("tessellationShader", static_cast<bool>(obj.tessellationShader));
+    p.PrintKeyBool("sampleRateShading", static_cast<bool>(obj.sampleRateShading));
+    p.PrintKeyBool("dualSrcBlend", static_cast<bool>(obj.dualSrcBlend));
+    p.PrintKeyBool("logicOp", static_cast<bool>(obj.logicOp));
+    p.PrintKeyBool("multiDrawIndirect", static_cast<bool>(obj.multiDrawIndirect));
+    p.PrintKeyBool("drawIndirectFirstInstance", static_cast<bool>(obj.drawIndirectFirstInstance));
+    p.PrintKeyBool("depthClamp", static_cast<bool>(obj.depthClamp));
+    p.PrintKeyBool("depthBiasClamp", static_cast<bool>(obj.depthBiasClamp));
+    p.PrintKeyBool("fillModeNonSolid", static_cast<bool>(obj.fillModeNonSolid));
+    p.PrintKeyBool("depthBounds", static_cast<bool>(obj.depthBounds));
+    p.PrintKeyBool("wideLines", static_cast<bool>(obj.wideLines));
+    p.PrintKeyBool("largePoints", static_cast<bool>(obj.largePoints));
+    p.PrintKeyBool("alphaToOne", static_cast<bool>(obj.alphaToOne));
+    p.PrintKeyBool("multiViewport", static_cast<bool>(obj.multiViewport));
+    p.PrintKeyBool("samplerAnisotropy", static_cast<bool>(obj.samplerAnisotropy));
+    p.PrintKeyBool("textureCompressionETC2", static_cast<bool>(obj.textureCompressionETC2));
+    p.PrintKeyBool("textureCompressionASTC_LDR", static_cast<bool>(obj.textureCompressionASTC_LDR));
+    p.PrintKeyBool("textureCompressionBC", static_cast<bool>(obj.textureCompressionBC));
+    p.PrintKeyBool("occlusionQueryPrecise", static_cast<bool>(obj.occlusionQueryPrecise));
+    p.PrintKeyBool("pipelineStatisticsQuery", static_cast<bool>(obj.pipelineStatisticsQuery));
+    p.PrintKeyBool("vertexPipelineStoresAndAtomics", static_cast<bool>(obj.vertexPipelineStoresAndAtomics));
+    p.PrintKeyBool("fragmentStoresAndAtomics", static_cast<bool>(obj.fragmentStoresAndAtomics));
+    p.PrintKeyBool("shaderTessellationAndGeometryPointSize", static_cast<bool>(obj.shaderTessellationAndGeometryPointSize));
+    p.PrintKeyBool("shaderImageGatherExtended", static_cast<bool>(obj.shaderImageGatherExtended));
+    p.PrintKeyBool("shaderStorageImageExtendedFormats", static_cast<bool>(obj.shaderStorageImageExtendedFormats));
+    p.PrintKeyBool("shaderStorageImageMultisample", static_cast<bool>(obj.shaderStorageImageMultisample));
+    p.PrintKeyBool("shaderStorageImageReadWithoutFormat", static_cast<bool>(obj.shaderStorageImageReadWithoutFormat));
+    p.PrintKeyBool("shaderStorageImageWriteWithoutFormat", static_cast<bool>(obj.shaderStorageImageWriteWithoutFormat));
+    p.PrintKeyBool("shaderUniformBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderUniformBufferArrayDynamicIndexing));
+    p.PrintKeyBool("shaderSampledImageArrayDynamicIndexing", static_cast<bool>(obj.shaderSampledImageArrayDynamicIndexing));
+    p.PrintKeyBool("shaderStorageBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageBufferArrayDynamicIndexing));
+    p.PrintKeyBool("shaderStorageImageArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageImageArrayDynamicIndexing));
+    p.PrintKeyBool("shaderClipDistance", static_cast<bool>(obj.shaderClipDistance));
+    p.PrintKeyBool("shaderCullDistance", static_cast<bool>(obj.shaderCullDistance));
+    p.PrintKeyBool("shaderFloat64", static_cast<bool>(obj.shaderFloat64));
+    p.PrintKeyBool("shaderInt64", static_cast<bool>(obj.shaderInt64));
+    p.PrintKeyBool("shaderInt16", static_cast<bool>(obj.shaderInt16));
+    p.PrintKeyBool("shaderResourceResidency", static_cast<bool>(obj.shaderResourceResidency));
+    p.PrintKeyBool("shaderResourceMinLod", static_cast<bool>(obj.shaderResourceMinLod));
+    p.PrintKeyBool("sparseBinding", static_cast<bool>(obj.sparseBinding));
+    p.PrintKeyBool("sparseResidencyBuffer", static_cast<bool>(obj.sparseResidencyBuffer));
+    p.PrintKeyBool("sparseResidencyImage2D", static_cast<bool>(obj.sparseResidencyImage2D));
+    p.PrintKeyBool("sparseResidencyImage3D", static_cast<bool>(obj.sparseResidencyImage3D));
+    p.PrintKeyBool("sparseResidency2Samples", static_cast<bool>(obj.sparseResidency2Samples));
+    p.PrintKeyBool("sparseResidency4Samples", static_cast<bool>(obj.sparseResidency4Samples));
+    p.PrintKeyBool("sparseResidency8Samples", static_cast<bool>(obj.sparseResidency8Samples));
+    p.PrintKeyBool("sparseResidency16Samples", static_cast<bool>(obj.sparseResidency16Samples));
+    p.PrintKeyBool("sparseResidencyAliased", static_cast<bool>(obj.sparseResidencyAliased));
+    p.PrintKeyBool("variableMultisampleRate", static_cast<bool>(obj.variableMultisampleRate));
+    p.PrintKeyBool("inheritedQueries", static_cast<bool>(obj.inheritedQueries));
+}
+void DumpVkPhysicalDeviceFloatControlsProperties(Printer &p, std::string name, const VkPhysicalDeviceFloatControlsProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(37);
+    DumpVkShaderFloatControlsIndependence(p, "denormBehaviorIndependence", obj.denormBehaviorIndependence);
+    DumpVkShaderFloatControlsIndependence(p, "roundingModeIndependence", obj.roundingModeIndependence);
+    p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat16", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat16));
+    p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat32", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat32));
+    p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat64", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat64));
+    p.PrintKeyBool("shaderDenormPreserveFloat16", static_cast<bool>(obj.shaderDenormPreserveFloat16));
+    p.PrintKeyBool("shaderDenormPreserveFloat32", static_cast<bool>(obj.shaderDenormPreserveFloat32));
+    p.PrintKeyBool("shaderDenormPreserveFloat64", static_cast<bool>(obj.shaderDenormPreserveFloat64));
+    p.PrintKeyBool("shaderDenormFlushToZeroFloat16", static_cast<bool>(obj.shaderDenormFlushToZeroFloat16));
+    p.PrintKeyBool("shaderDenormFlushToZeroFloat32", static_cast<bool>(obj.shaderDenormFlushToZeroFloat32));
+    p.PrintKeyBool("shaderDenormFlushToZeroFloat64", static_cast<bool>(obj.shaderDenormFlushToZeroFloat64));
+    p.PrintKeyBool("shaderRoundingModeRTEFloat16", static_cast<bool>(obj.shaderRoundingModeRTEFloat16));
+    p.PrintKeyBool("shaderRoundingModeRTEFloat32", static_cast<bool>(obj.shaderRoundingModeRTEFloat32));
+    p.PrintKeyBool("shaderRoundingModeRTEFloat64", static_cast<bool>(obj.shaderRoundingModeRTEFloat64));
+    p.PrintKeyBool("shaderRoundingModeRTZFloat16", static_cast<bool>(obj.shaderRoundingModeRTZFloat16));
+    p.PrintKeyBool("shaderRoundingModeRTZFloat32", static_cast<bool>(obj.shaderRoundingModeRTZFloat32));
+    p.PrintKeyBool("shaderRoundingModeRTZFloat64", static_cast<bool>(obj.shaderRoundingModeRTZFloat64));
+}
+void DumpVkPhysicalDeviceFragmentDensityMap2FeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("fragmentDensityMapDeferred", static_cast<bool>(obj.fragmentDensityMapDeferred));
+}
+void DumpVkPhysicalDeviceFragmentDensityMap2PropertiesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(41);
+    p.PrintKeyBool("subsampledLoads", static_cast<bool>(obj.subsampledLoads));
+    p.PrintKeyBool("subsampledCoarseReconstructionEarlyAccess", static_cast<bool>(obj.subsampledCoarseReconstructionEarlyAccess));
+    p.PrintKeyValue("maxSubsampledArrayLayers", obj.maxSubsampledArrayLayers);
+    p.PrintKeyValue("maxDescriptorSetSubsampledSamplers", obj.maxDescriptorSetSubsampledSamplers);
+}
+void DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceFragmentDensityMapFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(37);
+    p.PrintKeyBool("fragmentDensityMap", static_cast<bool>(obj.fragmentDensityMap));
+    p.PrintKeyBool("fragmentDensityMapDynamic", static_cast<bool>(obj.fragmentDensityMapDynamic));
+    p.PrintKeyBool("fragmentDensityMapNonSubsampledImages", static_cast<bool>(obj.fragmentDensityMapNonSubsampledImages));
+}
+void DumpVkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(24);
+    p.PrintKeyBool("fragmentDensityMapOffset", static_cast<bool>(obj.fragmentDensityMapOffset));
+}
+void DumpVkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkExtent2D(p, "fragmentDensityOffsetGranularity", obj.fragmentDensityOffsetGranularity);
+}
+void DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceFragmentDensityMapPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    DumpVkExtent2D(p, "minFragmentDensityTexelSize", obj.minFragmentDensityTexelSize);
+    DumpVkExtent2D(p, "maxFragmentDensityTexelSize", obj.maxFragmentDensityTexelSize);
+    p.PrintKeyBool("fragmentDensityInvocations", static_cast<bool>(obj.fragmentDensityInvocations));
+}
+void DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("fragmentShaderBarycentric", static_cast<bool>(obj.fragmentShaderBarycentric));
+}
+void DumpVkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(47);
+    p.PrintKeyBool("triStripVertexOrderIndependentOfProvokingVertex",
+                   static_cast<bool>(obj.triStripVertexOrderIndependentOfProvokingVertex));
+}
+void DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("fragmentShaderSampleInterlock", static_cast<bool>(obj.fragmentShaderSampleInterlock));
+    p.PrintKeyBool("fragmentShaderPixelInterlock", static_cast<bool>(obj.fragmentShaderPixelInterlock));
+    p.PrintKeyBool("fragmentShaderShadingRateInterlock", static_cast<bool>(obj.fragmentShaderShadingRateInterlock));
+}
+void DumpVkPhysicalDeviceFragmentShadingRateFeaturesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceFragmentShadingRateFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("pipelineFragmentShadingRate", static_cast<bool>(obj.pipelineFragmentShadingRate));
+    p.PrintKeyBool("primitiveFragmentShadingRate", static_cast<bool>(obj.primitiveFragmentShadingRate));
+    p.PrintKeyBool("attachmentFragmentShadingRate", static_cast<bool>(obj.attachmentFragmentShadingRate));
+}
+void DumpVkPhysicalDeviceFragmentShadingRateKHR(Printer &p, std::string name, const VkPhysicalDeviceFragmentShadingRateKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkSampleCountFlags(p, "sampleCounts", obj.sampleCounts);
+    DumpVkExtent2D(p, "fragmentSize", obj.fragmentSize);
+}
+void DumpVkPhysicalDeviceFragmentShadingRatePropertiesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceFragmentShadingRatePropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(52);
+    DumpVkExtent2D(p, "minFragmentShadingRateAttachmentTexelSize", obj.minFragmentShadingRateAttachmentTexelSize);
+    DumpVkExtent2D(p, "maxFragmentShadingRateAttachmentTexelSize", obj.maxFragmentShadingRateAttachmentTexelSize);
+    p.PrintKeyValue("maxFragmentShadingRateAttachmentTexelSizeAspectRatio",
+                    obj.maxFragmentShadingRateAttachmentTexelSizeAspectRatio);
+    p.PrintKeyBool("primitiveFragmentShadingRateWithMultipleViewports",
+                   static_cast<bool>(obj.primitiveFragmentShadingRateWithMultipleViewports));
+    p.PrintKeyBool("layeredShadingRateAttachments", static_cast<bool>(obj.layeredShadingRateAttachments));
+    p.PrintKeyBool("fragmentShadingRateNonTrivialCombinerOps", static_cast<bool>(obj.fragmentShadingRateNonTrivialCombinerOps));
+    DumpVkExtent2D(p, "maxFragmentSize", obj.maxFragmentSize);
+    p.PrintKeyValue("maxFragmentSizeAspectRatio", obj.maxFragmentSizeAspectRatio);
+    p.PrintKeyValue("maxFragmentShadingRateCoverageSamples", obj.maxFragmentShadingRateCoverageSamples);
+    DumpVkSampleCountFlagBits(p, "maxFragmentShadingRateRasterizationSamples", obj.maxFragmentShadingRateRasterizationSamples);
+    p.PrintKeyBool("fragmentShadingRateWithShaderDepthStencilWrites",
+                   static_cast<bool>(obj.fragmentShadingRateWithShaderDepthStencilWrites));
+    p.PrintKeyBool("fragmentShadingRateWithSampleMask", static_cast<bool>(obj.fragmentShadingRateWithSampleMask));
+    p.PrintKeyBool("fragmentShadingRateWithShaderSampleMask", static_cast<bool>(obj.fragmentShadingRateWithShaderSampleMask));
+    p.PrintKeyBool("fragmentShadingRateWithConservativeRasterization",
+                   static_cast<bool>(obj.fragmentShadingRateWithConservativeRasterization));
+    p.PrintKeyBool("fragmentShadingRateWithFragmentShaderInterlock",
+                   static_cast<bool>(obj.fragmentShadingRateWithFragmentShaderInterlock));
+    p.PrintKeyBool("fragmentShadingRateWithCustomSampleLocations",
+                   static_cast<bool>(obj.fragmentShadingRateWithCustomSampleLocations));
+    p.PrintKeyBool("fragmentShadingRateStrictMultiplyCombiner", static_cast<bool>(obj.fragmentShadingRateStrictMultiplyCombiner));
+}
+void DumpVkPhysicalDeviceFrameBoundaryFeaturesEXT(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceFrameBoundaryFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyBool("frameBoundary", static_cast<bool>(obj.frameBoundary));
+}
+void DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceGlobalPriorityQueryFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("globalPriorityQuery", static_cast<bool>(obj.globalPriorityQuery));
+}
+void DumpVkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("graphicsPipelineLibrary", static_cast<bool>(obj.graphicsPipelineLibrary));
+}
+void DumpVkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(57);
+    p.PrintKeyBool("graphicsPipelineLibraryFastLinking", static_cast<bool>(obj.graphicsPipelineLibraryFastLinking));
+    p.PrintKeyBool("graphicsPipelineLibraryIndependentInterpolationDecoration",
+                   static_cast<bool>(obj.graphicsPipelineLibraryIndependentInterpolationDecoration));
+}
+void DumpVkPhysicalDeviceHostImageCopyFeatures(Printer &p, std::string name, const VkPhysicalDeviceHostImageCopyFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyBool("hostImageCopy", static_cast<bool>(obj.hostImageCopy));
+}
+void DumpVkPhysicalDeviceHostImageCopyProperties(Printer &p, std::string name, const VkPhysicalDeviceHostImageCopyProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(31);
+    p.PrintKeyValue("copySrcLayoutCount", obj.copySrcLayoutCount);
+    if (obj.copySrcLayoutCount == 0 || obj.pCopySrcLayouts == nullptr) {
+        p.PrintKeyString("pCopySrcLayouts", "NULL");
+    } else {
+        ArrayWrapper arr(p, "pCopySrcLayouts", obj.copySrcLayoutCount);
+        for (uint32_t i = 0; i < obj.copySrcLayoutCount; i++) {
+            DumpVkImageLayout(p, std::to_string(i), obj.pCopySrcLayouts[i]);
+        }
+    }
+    p.PrintKeyValue("copyDstLayoutCount", obj.copyDstLayoutCount);
+    if (obj.copyDstLayoutCount == 0 || obj.pCopyDstLayouts == nullptr) {
+        p.PrintKeyString("pCopyDstLayouts", "NULL");
+    } else {
+        ArrayWrapper arr(p, "pCopyDstLayouts", obj.copyDstLayoutCount);
+        for (uint32_t i = 0; i < obj.copyDstLayoutCount; i++) {
+            DumpVkImageLayout(p, std::to_string(i), obj.pCopyDstLayouts[i]);
+        }
+    }
+    p.PrintKeyValue("optimalTilingLayoutUUID", obj.optimalTilingLayoutUUID);
+    p.PrintKeyBool("identicalMemoryTypeRequirements", static_cast<bool>(obj.identicalMemoryTypeRequirements));
+}
+void DumpVkPhysicalDeviceHostQueryResetFeatures(Printer &p, std::string name, const VkPhysicalDeviceHostQueryResetFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyBool("hostQueryReset", static_cast<bool>(obj.hostQueryReset));
+}
+void DumpVkPhysicalDeviceIDProperties(Printer &p, std::string name, const VkPhysicalDeviceIDProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(15);
+    p.PrintKeyValue("deviceUUID", obj.deviceUUID);
+    p.PrintKeyValue("driverUUID", obj.driverUUID);
+    if (obj.deviceLUIDValid) {  // special case
+        p.PrintKeyValue("deviceLUID", obj.deviceLUID);
+    }
+    p.PrintKeyValue("deviceNodeMask", obj.deviceNodeMask);
+    p.PrintKeyBool("deviceLUIDValid", static_cast<bool>(obj.deviceLUIDValid));
+}
+void DumpVkPhysicalDeviceImage2DViewOf3DFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("image2DViewOf3D", static_cast<bool>(obj.image2DViewOf3D));
+    p.PrintKeyBool("sampler2DViewOf3D", static_cast<bool>(obj.sampler2DViewOf3D));
+}
+void DumpVkPhysicalDeviceImageCompressionControlFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceImageCompressionControlFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("imageCompressionControl", static_cast<bool>(obj.imageCompressionControl));
+}
+void DumpVkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyBool("imageCompressionControlSwapchain", static_cast<bool>(obj.imageCompressionControlSwapchain));
+}
+void DumpVkPhysicalDeviceImageRobustnessFeatures(Printer &p, std::string name, const VkPhysicalDeviceImageRobustnessFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("robustImageAccess", static_cast<bool>(obj.robustImageAccess));
+}
+void DumpVkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("imageSlicedViewOf3D", static_cast<bool>(obj.imageSlicedViewOf3D));
+}
+void DumpVkPhysicalDeviceImageViewMinLodFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceImageViewMinLodFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(6);
+    p.PrintKeyBool("minLod", static_cast<bool>(obj.minLod));
+}
+void DumpVkPhysicalDeviceImagelessFramebufferFeatures(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceImagelessFramebufferFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("imagelessFramebuffer", static_cast<bool>(obj.imagelessFramebuffer));
+}
+void DumpVkPhysicalDeviceIndexTypeUint8Features(Printer &p, std::string name, const VkPhysicalDeviceIndexTypeUint8Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyBool("indexTypeUint8", static_cast<bool>(obj.indexTypeUint8));
+}
+void DumpVkPhysicalDeviceInlineUniformBlockFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceInlineUniformBlockFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(50);
+    p.PrintKeyBool("inlineUniformBlock", static_cast<bool>(obj.inlineUniformBlock));
+    p.PrintKeyBool("descriptorBindingInlineUniformBlockUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingInlineUniformBlockUpdateAfterBind));
+}
+void DumpVkPhysicalDeviceInlineUniformBlockProperties(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceInlineUniformBlockProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(55);
+    p.PrintKeyValue("maxInlineUniformBlockSize", obj.maxInlineUniformBlockSize);
+    p.PrintKeyValue("maxPerStageDescriptorInlineUniformBlocks", obj.maxPerStageDescriptorInlineUniformBlocks);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks",
+                    obj.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
+    p.PrintKeyValue("maxDescriptorSetInlineUniformBlocks", obj.maxDescriptorSetInlineUniformBlocks);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInlineUniformBlocks", obj.maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
+}
+void DumpVkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("internallySynchronizedQueues", static_cast<bool>(obj.internallySynchronizedQueues));
+}
+void DumpVkPhysicalDeviceLayeredApiPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceLayeredApiPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(10);
+    p.PrintKeyValue("vendorID", to_hex_str(p, obj.vendorID));
+    p.PrintKeyValue("deviceID", to_hex_str(p, obj.deviceID));
+    DumpVkPhysicalDeviceLayeredApiKHR(p, "layeredAPI", obj.layeredAPI);
+    p.PrintKeyString("deviceName", obj.deviceName);
+}
+void DumpVkPhysicalDeviceLayeredApiPropertiesListKHR(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceLayeredApiPropertiesListKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(15);
+    p.PrintKeyValue("layeredApiCount", obj.layeredApiCount);
+    if (obj.layeredApiCount == 0 || obj.pLayeredApis == nullptr) {
+        p.PrintKeyString("pLayeredApis", "NULL");
+    } else {
+        ArrayWrapper arr(p, "pLayeredApis", obj.layeredApiCount);
+        for (uint32_t i = 0; i < obj.layeredApiCount; i++) {
+            DumpVkPhysicalDeviceLayeredApiPropertiesKHR(p, std::to_string(i), obj.pLayeredApis[i]);
+        }
+    }
+}
+void DumpVkPhysicalDeviceLegacyDitheringFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceLegacyDitheringFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(15);
+    p.PrintKeyBool("legacyDithering", static_cast<bool>(obj.legacyDithering));
+}
+void DumpVkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    p.PrintKeyBool("legacyVertexAttributes", static_cast<bool>(obj.legacyVertexAttributes));
+}
+void DumpVkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("nativeUnalignedPerformance", static_cast<bool>(obj.nativeUnalignedPerformance));
+}
+void DumpVkPhysicalDeviceLimits(Printer &p, std::string name, const VkPhysicalDeviceLimits &obj) {
+    if (p.Type() == OutputType::json)
+        p.ObjectStart("limits");
+    else
+        p.SetSubHeader().ObjectStart(name);
+    p.SetMinKeyWidth(47);
+    p.PrintKeyValue("maxImageDimension1D", obj.maxImageDimension1D);
+    p.PrintKeyValue("maxImageDimension2D", obj.maxImageDimension2D);
+    p.PrintKeyValue("maxImageDimension3D", obj.maxImageDimension3D);
+    p.PrintKeyValue("maxImageDimensionCube", obj.maxImageDimensionCube);
+    p.PrintKeyValue("maxImageArrayLayers", obj.maxImageArrayLayers);
+    p.PrintKeyValue("maxTexelBufferElements", obj.maxTexelBufferElements);
+    p.PrintKeyValue("maxUniformBufferRange", obj.maxUniformBufferRange);
+    p.PrintKeyValue("maxStorageBufferRange", obj.maxStorageBufferRange);
+    p.PrintKeyValue("maxPushConstantsSize", obj.maxPushConstantsSize);
+    p.PrintKeyValue("maxMemoryAllocationCount", obj.maxMemoryAllocationCount);
+    p.PrintKeyValue("maxSamplerAllocationCount", obj.maxSamplerAllocationCount);
+    p.PrintKeyValue("bufferImageGranularity", to_hex_str(p, obj.bufferImageGranularity));
+    p.PrintKeyValue("sparseAddressSpaceSize", to_hex_str(p, obj.sparseAddressSpaceSize));
+    p.PrintKeyValue("maxBoundDescriptorSets", obj.maxBoundDescriptorSets);
+    p.PrintKeyValue("maxPerStageDescriptorSamplers", obj.maxPerStageDescriptorSamplers);
+    p.PrintKeyValue("maxPerStageDescriptorUniformBuffers", obj.maxPerStageDescriptorUniformBuffers);
+    p.PrintKeyValue("maxPerStageDescriptorStorageBuffers", obj.maxPerStageDescriptorStorageBuffers);
+    p.PrintKeyValue("maxPerStageDescriptorSampledImages", obj.maxPerStageDescriptorSampledImages);
+    p.PrintKeyValue("maxPerStageDescriptorStorageImages", obj.maxPerStageDescriptorStorageImages);
+    p.PrintKeyValue("maxPerStageDescriptorInputAttachments", obj.maxPerStageDescriptorInputAttachments);
+    p.PrintKeyValue("maxPerStageResources", obj.maxPerStageResources);
+    p.PrintKeyValue("maxDescriptorSetSamplers", obj.maxDescriptorSetSamplers);
+    p.PrintKeyValue("maxDescriptorSetUniformBuffers", obj.maxDescriptorSetUniformBuffers);
+    p.PrintKeyValue("maxDescriptorSetUniformBuffersDynamic", obj.maxDescriptorSetUniformBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetStorageBuffers", obj.maxDescriptorSetStorageBuffers);
+    p.PrintKeyValue("maxDescriptorSetStorageBuffersDynamic", obj.maxDescriptorSetStorageBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetSampledImages", obj.maxDescriptorSetSampledImages);
+    p.PrintKeyValue("maxDescriptorSetStorageImages", obj.maxDescriptorSetStorageImages);
+    p.PrintKeyValue("maxDescriptorSetInputAttachments", obj.maxDescriptorSetInputAttachments);
+    p.PrintKeyValue("maxVertexInputAttributes", obj.maxVertexInputAttributes);
+    p.PrintKeyValue("maxVertexInputBindings", obj.maxVertexInputBindings);
+    p.PrintKeyValue("maxVertexInputAttributeOffset", obj.maxVertexInputAttributeOffset);
+    p.PrintKeyValue("maxVertexInputBindingStride", obj.maxVertexInputBindingStride);
+    p.PrintKeyValue("maxVertexOutputComponents", obj.maxVertexOutputComponents);
+    p.PrintKeyValue("maxTessellationGenerationLevel", obj.maxTessellationGenerationLevel);
+    p.PrintKeyValue("maxTessellationPatchSize", obj.maxTessellationPatchSize);
+    p.PrintKeyValue("maxTessellationControlPerVertexInputComponents", obj.maxTessellationControlPerVertexInputComponents);
+    p.PrintKeyValue("maxTessellationControlPerVertexOutputComponents", obj.maxTessellationControlPerVertexOutputComponents);
+    p.PrintKeyValue("maxTessellationControlPerPatchOutputComponents", obj.maxTessellationControlPerPatchOutputComponents);
+    p.PrintKeyValue("maxTessellationControlTotalOutputComponents", obj.maxTessellationControlTotalOutputComponents);
+    p.PrintKeyValue("maxTessellationEvaluationInputComponents", obj.maxTessellationEvaluationInputComponents);
+    p.PrintKeyValue("maxTessellationEvaluationOutputComponents", obj.maxTessellationEvaluationOutputComponents);
+    p.PrintKeyValue("maxGeometryShaderInvocations", obj.maxGeometryShaderInvocations);
+    p.PrintKeyValue("maxGeometryInputComponents", obj.maxGeometryInputComponents);
+    p.PrintKeyValue("maxGeometryOutputComponents", obj.maxGeometryOutputComponents);
+    p.PrintKeyValue("maxGeometryOutputVertices", obj.maxGeometryOutputVertices);
+    p.PrintKeyValue("maxGeometryTotalOutputComponents", obj.maxGeometryTotalOutputComponents);
+    p.PrintKeyValue("maxFragmentInputComponents", obj.maxFragmentInputComponents);
+    p.PrintKeyValue("maxFragmentOutputAttachments", obj.maxFragmentOutputAttachments);
+    p.PrintKeyValue("maxFragmentDualSrcAttachments", obj.maxFragmentDualSrcAttachments);
+    p.PrintKeyValue("maxFragmentCombinedOutputResources", obj.maxFragmentCombinedOutputResources);
+    p.PrintKeyValue("maxComputeSharedMemorySize", obj.maxComputeSharedMemorySize);
+    {
+        ArrayWrapper arr(p, "maxComputeWorkGroupCount", 3);
+        for (uint32_t i = 0; i < 3; i++) {
+            p.PrintElement(obj.maxComputeWorkGroupCount[i]);
+        }
+    }
+    p.PrintKeyValue("maxComputeWorkGroupInvocations", obj.maxComputeWorkGroupInvocations);
+    {
+        ArrayWrapper arr(p, "maxComputeWorkGroupSize", 3);
+        for (uint32_t i = 0; i < 3; i++) {
+            p.PrintElement(obj.maxComputeWorkGroupSize[i]);
+        }
+    }
+    p.PrintKeyValue("subPixelPrecisionBits", obj.subPixelPrecisionBits);
+    p.PrintKeyValue("subTexelPrecisionBits", obj.subTexelPrecisionBits);
+    p.PrintKeyValue("mipmapPrecisionBits", obj.mipmapPrecisionBits);
+    p.PrintKeyValue("maxDrawIndexedIndexValue", obj.maxDrawIndexedIndexValue);
+    p.PrintKeyValue("maxDrawIndirectCount", obj.maxDrawIndirectCount);
+    p.PrintKeyValue("maxSamplerLodBias", obj.maxSamplerLodBias);
+    p.PrintKeyValue("maxSamplerAnisotropy", obj.maxSamplerAnisotropy);
+    p.PrintKeyValue("maxViewports", obj.maxViewports);
+    {
+        ArrayWrapper arr(p, "maxViewportDimensions", 2);
+        for (uint32_t i = 0; i < 2; i++) {
+            p.PrintElement(obj.maxViewportDimensions[i]);
+        }
+    }
+    {
+        ArrayWrapper arr(p, "viewportBoundsRange", 2);
+        for (uint32_t i = 0; i < 2; i++) {
+            p.PrintElement(obj.viewportBoundsRange[i]);
+        }
+    }
+    p.PrintKeyValue("viewportSubPixelBits", obj.viewportSubPixelBits);
+    p.PrintKeyValue("minMemoryMapAlignment", obj.minMemoryMapAlignment);
+    p.PrintKeyValue("minTexelBufferOffsetAlignment", to_hex_str(p, obj.minTexelBufferOffsetAlignment));
+    p.PrintKeyValue("minUniformBufferOffsetAlignment", to_hex_str(p, obj.minUniformBufferOffsetAlignment));
+    p.PrintKeyValue("minStorageBufferOffsetAlignment", to_hex_str(p, obj.minStorageBufferOffsetAlignment));
+    p.PrintKeyValue("minTexelOffset", obj.minTexelOffset);
+    p.PrintKeyValue("maxTexelOffset", obj.maxTexelOffset);
+    p.PrintKeyValue("minTexelGatherOffset", obj.minTexelGatherOffset);
+    p.PrintKeyValue("maxTexelGatherOffset", obj.maxTexelGatherOffset);
+    p.PrintKeyValue("minInterpolationOffset", obj.minInterpolationOffset);
+    p.PrintKeyValue("maxInterpolationOffset", obj.maxInterpolationOffset);
+    p.PrintKeyValue("subPixelInterpolationOffsetBits", obj.subPixelInterpolationOffsetBits);
+    p.PrintKeyValue("maxFramebufferWidth", obj.maxFramebufferWidth);
+    p.PrintKeyValue("maxFramebufferHeight", obj.maxFramebufferHeight);
+    p.PrintKeyValue("maxFramebufferLayers", obj.maxFramebufferLayers);
+    DumpVkSampleCountFlags(p, "framebufferColorSampleCounts", obj.framebufferColorSampleCounts);
+    DumpVkSampleCountFlags(p, "framebufferDepthSampleCounts", obj.framebufferDepthSampleCounts);
+    DumpVkSampleCountFlags(p, "framebufferStencilSampleCounts", obj.framebufferStencilSampleCounts);
+    DumpVkSampleCountFlags(p, "framebufferNoAttachmentsSampleCounts", obj.framebufferNoAttachmentsSampleCounts);
+    p.PrintKeyValue("maxColorAttachments", obj.maxColorAttachments);
+    DumpVkSampleCountFlags(p, "sampledImageColorSampleCounts", obj.sampledImageColorSampleCounts);
+    DumpVkSampleCountFlags(p, "sampledImageIntegerSampleCounts", obj.sampledImageIntegerSampleCounts);
+    DumpVkSampleCountFlags(p, "sampledImageDepthSampleCounts", obj.sampledImageDepthSampleCounts);
+    DumpVkSampleCountFlags(p, "sampledImageStencilSampleCounts", obj.sampledImageStencilSampleCounts);
+    DumpVkSampleCountFlags(p, "storageImageSampleCounts", obj.storageImageSampleCounts);
+    p.PrintKeyValue("maxSampleMaskWords", obj.maxSampleMaskWords);
+    p.PrintKeyBool("timestampComputeAndGraphics", static_cast<bool>(obj.timestampComputeAndGraphics));
+    p.PrintKeyValue("timestampPeriod", obj.timestampPeriod);
+    p.PrintKeyValue("maxClipDistances", obj.maxClipDistances);
+    p.PrintKeyValue("maxCullDistances", obj.maxCullDistances);
+    p.PrintKeyValue("maxCombinedClipAndCullDistances", obj.maxCombinedClipAndCullDistances);
+    p.PrintKeyValue("discreteQueuePriorities", obj.discreteQueuePriorities);
+    {
+        ArrayWrapper arr(p, "pointSizeRange", 2);
+        for (uint32_t i = 0; i < 2; i++) {
+            p.PrintElement(obj.pointSizeRange[i]);
+        }
+    }
+    {
+        ArrayWrapper arr(p, "lineWidthRange", 2);
+        for (uint32_t i = 0; i < 2; i++) {
+            p.PrintElement(obj.lineWidthRange[i]);
+        }
+    }
+    p.PrintKeyValue("pointSizeGranularity", obj.pointSizeGranularity);
+    p.PrintKeyValue("lineWidthGranularity", obj.lineWidthGranularity);
+    p.PrintKeyBool("strictLines", static_cast<bool>(obj.strictLines));
+    p.PrintKeyBool("standardSampleLocations", static_cast<bool>(obj.standardSampleLocations));
+    p.PrintKeyValue("optimalBufferCopyOffsetAlignment", to_hex_str(p, obj.optimalBufferCopyOffsetAlignment));
+    p.PrintKeyValue("optimalBufferCopyRowPitchAlignment", to_hex_str(p, obj.optimalBufferCopyRowPitchAlignment));
+    p.PrintKeyValue("nonCoherentAtomSize", to_hex_str(p, obj.nonCoherentAtomSize));
+    p.ObjectEnd();
+}
+void DumpVkPhysicalDeviceLineRasterizationFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceLineRasterizationFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(24);
+    p.PrintKeyBool("rectangularLines", static_cast<bool>(obj.rectangularLines));
+    p.PrintKeyBool("bresenhamLines", static_cast<bool>(obj.bresenhamLines));
+    p.PrintKeyBool("smoothLines", static_cast<bool>(obj.smoothLines));
+    p.PrintKeyBool("stippledRectangularLines", static_cast<bool>(obj.stippledRectangularLines));
+    p.PrintKeyBool("stippledBresenhamLines", static_cast<bool>(obj.stippledBresenhamLines));
+    p.PrintKeyBool("stippledSmoothLines", static_cast<bool>(obj.stippledSmoothLines));
+}
+void DumpVkPhysicalDeviceLineRasterizationProperties(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceLineRasterizationProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyValue("lineSubPixelPrecisionBits", obj.lineSubPixelPrecisionBits);
+}
+void DumpVkPhysicalDeviceMaintenance10FeaturesKHR(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceMaintenance10FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyBool("maintenance10", static_cast<bool>(obj.maintenance10));
+}
+void DumpVkPhysicalDeviceMaintenance10PropertiesKHR(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceMaintenance10PropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(48);
+    p.PrintKeyBool("rgba4OpaqueBlackSwizzled", static_cast<bool>(obj.rgba4OpaqueBlackSwizzled));
+    p.PrintKeyBool("resolveSrgbFormatAppliesTransferFunction", static_cast<bool>(obj.resolveSrgbFormatAppliesTransferFunction));
+    p.PrintKeyBool("resolveSrgbFormatSupportsTransferFunctionControl",
+                   static_cast<bool>(obj.resolveSrgbFormatSupportsTransferFunctionControl));
+}
+void DumpVkPhysicalDeviceMaintenance3Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance3Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyValue("maxPerSetDescriptors", obj.maxPerSetDescriptors);
+    p.PrintKeyValue("maxMemoryAllocationSize", to_hex_str(p, obj.maxMemoryAllocationSize));
+}
+void DumpVkPhysicalDeviceMaintenance4Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance4Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("maintenance4", static_cast<bool>(obj.maintenance4));
+}
+void DumpVkPhysicalDeviceMaintenance4Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance4Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyValue("maxBufferSize", to_hex_str(p, obj.maxBufferSize));
+}
+void DumpVkPhysicalDeviceMaintenance5Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance5Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("maintenance5", static_cast<bool>(obj.maintenance5));
+}
+void DumpVkPhysicalDeviceMaintenance5Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance5Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(51);
+    p.PrintKeyBool("earlyFragmentMultisampleCoverageAfterSampleCounting",
+                   static_cast<bool>(obj.earlyFragmentMultisampleCoverageAfterSampleCounting));
+    p.PrintKeyBool("earlyFragmentSampleMaskTestBeforeSampleCounting",
+                   static_cast<bool>(obj.earlyFragmentSampleMaskTestBeforeSampleCounting));
+    p.PrintKeyBool("depthStencilSwizzleOneSupport", static_cast<bool>(obj.depthStencilSwizzleOneSupport));
+    p.PrintKeyBool("polygonModePointSize", static_cast<bool>(obj.polygonModePointSize));
+    p.PrintKeyBool("nonStrictSinglePixelWideLinesUseParallelogram",
+                   static_cast<bool>(obj.nonStrictSinglePixelWideLinesUseParallelogram));
+    p.PrintKeyBool("nonStrictWideLinesUseParallelogram", static_cast<bool>(obj.nonStrictWideLinesUseParallelogram));
+}
+void DumpVkPhysicalDeviceMaintenance6Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance6Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("maintenance6", static_cast<bool>(obj.maintenance6));
+}
+void DumpVkPhysicalDeviceMaintenance6Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance6Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyBool("blockTexelViewCompatibleMultipleLayers", static_cast<bool>(obj.blockTexelViewCompatibleMultipleLayers));
+    p.PrintKeyValue("maxCombinedImageSamplerDescriptorCount", obj.maxCombinedImageSamplerDescriptorCount);
+    p.PrintKeyBool("fragmentShadingRateClampCombinerInputs", static_cast<bool>(obj.fragmentShadingRateClampCombinerInputs));
+}
+void DumpVkPhysicalDeviceMaintenance7FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance7FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("maintenance7", static_cast<bool>(obj.maintenance7));
+}
+void DumpVkPhysicalDeviceMaintenance7PropertiesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMaintenance7PropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(57);
+    p.PrintKeyBool("robustFragmentShadingRateAttachmentAccess", static_cast<bool>(obj.robustFragmentShadingRateAttachmentAccess));
+    p.PrintKeyBool("separateDepthStencilAttachmentAccess", static_cast<bool>(obj.separateDepthStencilAttachmentAccess));
+    p.PrintKeyValue("maxDescriptorSetTotalUniformBuffersDynamic", obj.maxDescriptorSetTotalUniformBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetTotalStorageBuffersDynamic", obj.maxDescriptorSetTotalStorageBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetTotalBuffersDynamic", obj.maxDescriptorSetTotalBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic",
+                    obj.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic",
+                    obj.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindTotalBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic);
+}
+void DumpVkPhysicalDeviceMaintenance8FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance8FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("maintenance8", static_cast<bool>(obj.maintenance8));
+}
+void DumpVkPhysicalDeviceMaintenance9FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance9FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("maintenance9", static_cast<bool>(obj.maintenance9));
+}
+void DumpVkPhysicalDeviceMaintenance9PropertiesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMaintenance9PropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("image2DViewOf3DSparse", static_cast<bool>(obj.image2DViewOf3DSparse));
+    DumpVkDefaultVertexAttributeValueKHR(p, "defaultVertexAttributeValue", obj.defaultVertexAttributeValue);
+}
+void DumpVkPhysicalDeviceMapMemoryPlacedFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("memoryMapPlaced", static_cast<bool>(obj.memoryMapPlaced));
+    p.PrintKeyBool("memoryMapRangePlaced", static_cast<bool>(obj.memoryMapRangePlaced));
+    p.PrintKeyBool("memoryUnmapReserve", static_cast<bool>(obj.memoryUnmapReserve));
+}
+void DumpVkPhysicalDeviceMapMemoryPlacedPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyValue("minPlacedMemoryMapAlignment", to_hex_str(p, obj.minPlacedMemoryMapAlignment));
+}
+void DumpVkPhysicalDeviceMemoryBudgetPropertiesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMemoryBudgetPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    {
+        ArrayWrapper arr(p, "heapBudget", VK_MAX_MEMORY_HEAPS);
+        for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) {
+            p.PrintElement(obj.heapBudget[i]);
+        }
+    }
+    {
+        ArrayWrapper arr(p, "heapUsage", VK_MAX_MEMORY_HEAPS);
+        for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) {
+            p.PrintElement(obj.heapUsage[i]);
+        }
+    }
+}
+void DumpVkPhysicalDeviceMemoryDecompressionFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceMemoryDecompressionFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("memoryDecompression", static_cast<bool>(obj.memoryDecompression));
+}
+void DumpVkPhysicalDeviceMemoryDecompressionPropertiesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceMemoryDecompressionPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    DumpVkMemoryDecompressionMethodFlagsEXT(p, "decompressionMethods", obj.decompressionMethods);
+    p.PrintKeyValue("maxDecompressionIndirectCount", obj.maxDecompressionIndirectCount);
+}
+void DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMemoryPriorityFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyBool("memoryPriority", static_cast<bool>(obj.memoryPriority));
+}
+void DumpVkPhysicalDeviceMeshShaderFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMeshShaderFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyBool("taskShader", static_cast<bool>(obj.taskShader));
+    p.PrintKeyBool("meshShader", static_cast<bool>(obj.meshShader));
+    p.PrintKeyBool("multiviewMeshShader", static_cast<bool>(obj.multiviewMeshShader));
+    p.PrintKeyBool("primitiveFragmentShadingRateMeshShader", static_cast<bool>(obj.primitiveFragmentShadingRateMeshShader));
+    p.PrintKeyBool("meshShaderQueries", static_cast<bool>(obj.meshShaderQueries));
+}
+void DumpVkPhysicalDeviceMeshShaderPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceMeshShaderPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(37);
+    p.PrintKeyValue("maxTaskWorkGroupTotalCount", obj.maxTaskWorkGroupTotalCount);
+    {
+        ArrayWrapper arr(p, "maxTaskWorkGroupCount", 3);
+        for (uint32_t i = 0; i < 3; i++) {
+            p.PrintElement(obj.maxTaskWorkGroupCount[i]);
+        }
+    }
+    p.PrintKeyValue("maxTaskWorkGroupInvocations", obj.maxTaskWorkGroupInvocations);
+    {
+        ArrayWrapper arr(p, "maxTaskWorkGroupSize", 3);
+        for (uint32_t i = 0; i < 3; i++) {
+            p.PrintElement(obj.maxTaskWorkGroupSize[i]);
+        }
+    }
+    p.PrintKeyValue("maxTaskPayloadSize", obj.maxTaskPayloadSize);
+    p.PrintKeyValue("maxTaskSharedMemorySize", obj.maxTaskSharedMemorySize);
+    p.PrintKeyValue("maxTaskPayloadAndSharedMemorySize", obj.maxTaskPayloadAndSharedMemorySize);
+    p.PrintKeyValue("maxMeshWorkGroupTotalCount", obj.maxMeshWorkGroupTotalCount);
+    {
+        ArrayWrapper arr(p, "maxMeshWorkGroupCount", 3);
+        for (uint32_t i = 0; i < 3; i++) {
+            p.PrintElement(obj.maxMeshWorkGroupCount[i]);
+        }
+    }
+    p.PrintKeyValue("maxMeshWorkGroupInvocations", obj.maxMeshWorkGroupInvocations);
+    {
+        ArrayWrapper arr(p, "maxMeshWorkGroupSize", 3);
+        for (uint32_t i = 0; i < 3; i++) {
+            p.PrintElement(obj.maxMeshWorkGroupSize[i]);
+        }
+    }
+    p.PrintKeyValue("maxMeshSharedMemorySize", obj.maxMeshSharedMemorySize);
+    p.PrintKeyValue("maxMeshPayloadAndSharedMemorySize", obj.maxMeshPayloadAndSharedMemorySize);
+    p.PrintKeyValue("maxMeshOutputMemorySize", obj.maxMeshOutputMemorySize);
+    p.PrintKeyValue("maxMeshPayloadAndOutputMemorySize", obj.maxMeshPayloadAndOutputMemorySize);
+    p.PrintKeyValue("maxMeshOutputComponents", obj.maxMeshOutputComponents);
+    p.PrintKeyValue("maxMeshOutputVertices", obj.maxMeshOutputVertices);
+    p.PrintKeyValue("maxMeshOutputPrimitives", obj.maxMeshOutputPrimitives);
+    p.PrintKeyValue("maxMeshOutputLayers", obj.maxMeshOutputLayers);
+    p.PrintKeyValue("maxMeshMultiviewViewCount", obj.maxMeshMultiviewViewCount);
+    p.PrintKeyValue("meshOutputPerVertexGranularity", obj.meshOutputPerVertexGranularity);
+    p.PrintKeyValue("meshOutputPerPrimitiveGranularity", obj.meshOutputPerPrimitiveGranularity);
+    p.PrintKeyValue("maxPreferredTaskWorkGroupInvocations", obj.maxPreferredTaskWorkGroupInvocations);
+    p.PrintKeyValue("maxPreferredMeshWorkGroupInvocations", obj.maxPreferredMeshWorkGroupInvocations);
+    p.PrintKeyBool("prefersLocalInvocationVertexOutput", static_cast<bool>(obj.prefersLocalInvocationVertexOutput));
+    p.PrintKeyBool("prefersLocalInvocationPrimitiveOutput", static_cast<bool>(obj.prefersLocalInvocationPrimitiveOutput));
+    p.PrintKeyBool("prefersCompactVertexOutput", static_cast<bool>(obj.prefersCompactVertexOutput));
+    p.PrintKeyBool("prefersCompactPrimitiveOutput", static_cast<bool>(obj.prefersCompactPrimitiveOutput));
+}
+void DumpVkPhysicalDeviceMultiDrawFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMultiDrawFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(9);
+    p.PrintKeyBool("multiDraw", static_cast<bool>(obj.multiDraw));
+}
+void DumpVkPhysicalDeviceMultiDrawPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceMultiDrawPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyValue("maxMultiDrawCount", obj.maxMultiDrawCount);
+}
+void DumpVkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyBool("multisampledRenderToSingleSampled", static_cast<bool>(obj.multisampledRenderToSingleSampled));
+}
+void DumpVkPhysicalDeviceMultiviewFeatures(Printer &p, std::string name, const VkPhysicalDeviceMultiviewFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("multiview", static_cast<bool>(obj.multiview));
+    p.PrintKeyBool("multiviewGeometryShader", static_cast<bool>(obj.multiviewGeometryShader));
+    p.PrintKeyBool("multiviewTessellationShader", static_cast<bool>(obj.multiviewTessellationShader));
+}
+void DumpVkPhysicalDeviceMultiviewProperties(Printer &p, std::string name, const VkPhysicalDeviceMultiviewProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyValue("maxMultiviewViewCount", obj.maxMultiviewViewCount);
+    p.PrintKeyValue("maxMultiviewInstanceIndex", obj.maxMultiviewInstanceIndex);
+}
+void DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("mutableDescriptorType", static_cast<bool>(obj.mutableDescriptorType));
+}
+void DumpVkPhysicalDeviceNestedCommandBufferFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceNestedCommandBufferFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("nestedCommandBuffer", static_cast<bool>(obj.nestedCommandBuffer));
+    p.PrintKeyBool("nestedCommandBufferRendering", static_cast<bool>(obj.nestedCommandBufferRendering));
+    p.PrintKeyBool("nestedCommandBufferSimultaneousUse", static_cast<bool>(obj.nestedCommandBufferSimultaneousUse));
+}
+void DumpVkPhysicalDeviceNestedCommandBufferPropertiesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceNestedCommandBufferPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyValue("maxCommandBufferNestingLevel", obj.maxCommandBufferNestingLevel);
+}
+void DumpVkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(18);
+    p.PrintKeyBool("nonSeamlessCubeMap", static_cast<bool>(obj.nonSeamlessCubeMap));
+}
+void DumpVkPhysicalDeviceOpacityMicromapFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceOpacityMicromapFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("micromap", static_cast<bool>(obj.micromap));
+    p.PrintKeyBool("micromapCaptureReplay", static_cast<bool>(obj.micromapCaptureReplay));
+    p.PrintKeyBool("micromapHostCommands", static_cast<bool>(obj.micromapHostCommands));
+}
+void DumpVkPhysicalDeviceOpacityMicromapPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceOpacityMicromapPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyValue("maxOpacity2StateSubdivisionLevel", obj.maxOpacity2StateSubdivisionLevel);
+    p.PrintKeyValue("maxOpacity4StateSubdivisionLevel", obj.maxOpacity4StateSubdivisionLevel);
+}
+void DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(Printer &p, std::string name, const VkPhysicalDevicePCIBusInfoPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(11);
+    p.PrintKeyValue("pciDomain", obj.pciDomain);
+    p.PrintKeyValue("pciBus", obj.pciBus);
+    p.PrintKeyValue("pciDevice", obj.pciDevice);
+    p.PrintKeyValue("pciFunction", obj.pciFunction);
+}
+void DumpVkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("pageableDeviceLocalMemory", static_cast<bool>(obj.pageableDeviceLocalMemory));
+}
+void DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(Printer &p, std::string name,
+                                                     const VkPhysicalDevicePerformanceQueryFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(36);
+    p.PrintKeyBool("performanceCounterQueryPools", static_cast<bool>(obj.performanceCounterQueryPools));
+    p.PrintKeyBool("performanceCounterMultipleQueryPools", static_cast<bool>(obj.performanceCounterMultipleQueryPools));
+}
+void DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDevicePerformanceQueryPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("allowCommandBufferQueryCopies", static_cast<bool>(obj.allowCommandBufferQueryCopies));
+}
+void DumpVkPhysicalDevicePipelineBinaryFeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDevicePipelineBinaryFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("pipelineBinaries", static_cast<bool>(obj.pipelineBinaries));
+}
+void DumpVkPhysicalDevicePipelineBinaryPropertiesKHR(Printer &p, std::string name,
+                                                     const VkPhysicalDevicePipelineBinaryPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyBool("pipelineBinaryInternalCache", static_cast<bool>(obj.pipelineBinaryInternalCache));
+    p.PrintKeyBool("pipelineBinaryInternalCacheControl", static_cast<bool>(obj.pipelineBinaryInternalCacheControl));
+    p.PrintKeyBool("pipelineBinaryPrefersInternalCache", static_cast<bool>(obj.pipelineBinaryPrefersInternalCache));
+    p.PrintKeyBool("pipelineBinaryPrecompiledInternalCache", static_cast<bool>(obj.pipelineBinaryPrecompiledInternalCache));
+    p.PrintKeyBool("pipelineBinaryCompressedData", static_cast<bool>(obj.pipelineBinaryCompressedData));
+}
+void DumpVkPhysicalDevicePipelineCreationCacheControlFeatures(Printer &p, std::string name,
+                                                              const VkPhysicalDevicePipelineCreationCacheControlFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("pipelineCreationCacheControl", static_cast<bool>(obj.pipelineCreationCacheControl));
+}
+void DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    p.PrintKeyBool("pipelineExecutableInfo", static_cast<bool>(obj.pipelineExecutableInfo));
+}
+void DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(Printer &p, std::string name,
+                                                                const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("pipelineLibraryGroupHandles", static_cast<bool>(obj.pipelineLibraryGroupHandles));
+}
+void DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDevicePipelinePropertiesFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("pipelinePropertiesIdentifier", static_cast<bool>(obj.pipelinePropertiesIdentifier));
+}
+void DumpVkPhysicalDevicePipelineProtectedAccessFeatures(Printer &p, std::string name,
+                                                         const VkPhysicalDevicePipelineProtectedAccessFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("pipelineProtectedAccess", static_cast<bool>(obj.pipelineProtectedAccess));
+}
+void DumpVkPhysicalDevicePipelineRobustnessFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDevicePipelineRobustnessFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(18);
+    p.PrintKeyBool("pipelineRobustness", static_cast<bool>(obj.pipelineRobustness));
+}
+void DumpVkPhysicalDevicePipelineRobustnessProperties(Printer &p, std::string name,
+                                                      const VkPhysicalDevicePipelineRobustnessProperties &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessStorageBuffers", obj.defaultRobustnessStorageBuffers);
+    DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessUniformBuffers", obj.defaultRobustnessUniformBuffers);
+    DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessVertexInputs", obj.defaultRobustnessVertexInputs);
+    DumpVkPipelineRobustnessImageBehavior(p, "defaultRobustnessImages", obj.defaultRobustnessImages);
+}
+void DumpVkPhysicalDevicePointClippingProperties(Printer &p, std::string name, const VkPhysicalDevicePointClippingProperties &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkPointClippingBehavior(p, "pointClippingBehavior", obj.pointClippingBehavior);
+}
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+void DumpVkPhysicalDevicePortabilitySubsetFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDevicePortabilitySubsetFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyBool("constantAlphaColorBlendFactors", static_cast<bool>(obj.constantAlphaColorBlendFactors));
+    p.PrintKeyBool("events", static_cast<bool>(obj.events));
+    p.PrintKeyBool("imageViewFormatReinterpretation", static_cast<bool>(obj.imageViewFormatReinterpretation));
+    p.PrintKeyBool("imageViewFormatSwizzle", static_cast<bool>(obj.imageViewFormatSwizzle));
+    p.PrintKeyBool("imageView2DOn3DImage", static_cast<bool>(obj.imageView2DOn3DImage));
+    p.PrintKeyBool("multisampleArrayImage", static_cast<bool>(obj.multisampleArrayImage));
+    p.PrintKeyBool("mutableComparisonSamplers", static_cast<bool>(obj.mutableComparisonSamplers));
+    p.PrintKeyBool("pointPolygons", static_cast<bool>(obj.pointPolygons));
+    p.PrintKeyBool("samplerMipLodBias", static_cast<bool>(obj.samplerMipLodBias));
+    p.PrintKeyBool("separateStencilMaskRef", static_cast<bool>(obj.separateStencilMaskRef));
+    p.PrintKeyBool("shaderSampleRateInterpolationFunctions", static_cast<bool>(obj.shaderSampleRateInterpolationFunctions));
+    p.PrintKeyBool("tessellationIsolines", static_cast<bool>(obj.tessellationIsolines));
+    p.PrintKeyBool("tessellationPointMode", static_cast<bool>(obj.tessellationPointMode));
+    p.PrintKeyBool("triangleFans", static_cast<bool>(obj.triangleFans));
+    p.PrintKeyBool("vertexAttributeAccessBeyondStride", static_cast<bool>(obj.vertexAttributeAccessBeyondStride));
+}
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+void DumpVkPhysicalDevicePortabilitySubsetPropertiesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDevicePortabilitySubsetPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(36);
+    p.PrintKeyValue("minVertexInputBindingStrideAlignment", obj.minVertexInputBindingStrideAlignment);
+}
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+void DumpVkPhysicalDevicePresentId2FeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentId2FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(10);
+    p.PrintKeyBool("presentId2", static_cast<bool>(obj.presentId2));
+}
+void DumpVkPhysicalDevicePresentIdFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentIdFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(9);
+    p.PrintKeyBool("presentId", static_cast<bool>(obj.presentId));
+}
+void DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("presentModeFifoLatestReady", static_cast<bool>(obj.presentModeFifoLatestReady));
+}
+void DumpVkPhysicalDevicePresentTimingFeaturesEXT(Printer &p, std::string name,
+                                                  const VkPhysicalDevicePresentTimingFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("presentTiming", static_cast<bool>(obj.presentTiming));
+    p.PrintKeyBool("presentAtAbsoluteTime", static_cast<bool>(obj.presentAtAbsoluteTime));
+    p.PrintKeyBool("presentAtRelativeTime", static_cast<bool>(obj.presentAtRelativeTime));
+}
+void DumpVkPhysicalDevicePresentWait2FeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentWait2FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("presentWait2", static_cast<bool>(obj.presentWait2));
+}
+void DumpVkPhysicalDevicePresentWaitFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentWaitFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(11);
+    p.PrintKeyBool("presentWait", static_cast<bool>(obj.presentWait));
+}
+void DumpVkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyBool("primitiveTopologyListRestart", static_cast<bool>(obj.primitiveTopologyListRestart));
+    p.PrintKeyBool("primitiveTopologyPatchListRestart", static_cast<bool>(obj.primitiveTopologyPatchListRestart));
+}
+void DumpVkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(45);
+    p.PrintKeyBool("primitivesGeneratedQuery", static_cast<bool>(obj.primitivesGeneratedQuery));
+    p.PrintKeyBool("primitivesGeneratedQueryWithRasterizerDiscard",
+                   static_cast<bool>(obj.primitivesGeneratedQueryWithRasterizerDiscard));
+    p.PrintKeyBool("primitivesGeneratedQueryWithNonZeroStreams", static_cast<bool>(obj.primitivesGeneratedQueryWithNonZeroStreams));
+}
+void DumpVkPhysicalDevicePrivateDataFeatures(Printer &p, std::string name, const VkPhysicalDevicePrivateDataFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(11);
+    p.PrintKeyBool("privateData", static_cast<bool>(obj.privateData));
+}
+void DumpVkPhysicalDeviceProtectedMemoryFeatures(Printer &p, std::string name, const VkPhysicalDeviceProtectedMemoryFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(15);
+    p.PrintKeyBool("protectedMemory", static_cast<bool>(obj.protectedMemory));
+}
+void DumpVkPhysicalDeviceProtectedMemoryProperties(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceProtectedMemoryProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("protectedNoFault", static_cast<bool>(obj.protectedNoFault));
+}
+void DumpVkPhysicalDeviceProvokingVertexFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceProvokingVertexFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(41);
+    p.PrintKeyBool("provokingVertexLast", static_cast<bool>(obj.provokingVertexLast));
+    p.PrintKeyBool("transformFeedbackPreservesProvokingVertex", static_cast<bool>(obj.transformFeedbackPreservesProvokingVertex));
+}
+void DumpVkPhysicalDeviceProvokingVertexPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceProvokingVertexPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(52);
+    p.PrintKeyBool("provokingVertexModePerPipeline", static_cast<bool>(obj.provokingVertexModePerPipeline));
+    p.PrintKeyBool("transformFeedbackPreservesTriangleFanProvokingVertex",
+                   static_cast<bool>(obj.transformFeedbackPreservesTriangleFanProvokingVertex));
+}
+void DumpVkPhysicalDevicePushDescriptorProperties(Printer &p, std::string name,
+                                                  const VkPhysicalDevicePushDescriptorProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(18);
+    p.PrintKeyValue("maxPushDescriptors", obj.maxPushDescriptors);
+}
+void DumpVkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyBool("formatRgba10x6WithoutYCbCrSampler", static_cast<bool>(obj.formatRgba10x6WithoutYCbCrSampler));
+}
+void DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(41);
+    p.PrintKeyBool("rasterizationOrderColorAttachmentAccess", static_cast<bool>(obj.rasterizationOrderColorAttachmentAccess));
+    p.PrintKeyBool("rasterizationOrderDepthAttachmentAccess", static_cast<bool>(obj.rasterizationOrderDepthAttachmentAccess));
+    p.PrintKeyBool("rasterizationOrderStencilAttachmentAccess", static_cast<bool>(obj.rasterizationOrderStencilAttachmentAccess));
+}
+void DumpVkPhysicalDeviceRayQueryFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceRayQueryFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(8);
+    p.PrintKeyBool("rayQuery", static_cast<bool>(obj.rayQuery));
+}
+void DumpVkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("rayTracingInvocationReorder", static_cast<bool>(obj.rayTracingInvocationReorder));
+}
+void DumpVkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    DumpVkRayTracingInvocationReorderModeEXT(p, "rayTracingInvocationReorderReorderingHint",
+                                             obj.rayTracingInvocationReorderReorderingHint);
+    p.PrintKeyValue("maxShaderBindingTableRecordIndex", obj.maxShaderBindingTableRecordIndex);
+}
+void DumpVkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(36);
+    p.PrintKeyBool("rayTracingMaintenance1", static_cast<bool>(obj.rayTracingMaintenance1));
+    p.PrintKeyBool("rayTracingPipelineTraceRaysIndirect2", static_cast<bool>(obj.rayTracingPipelineTraceRaysIndirect2));
+}
+void DumpVkPhysicalDeviceRayTracingPipelineFeaturesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceRayTracingPipelineFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(53);
+    p.PrintKeyBool("rayTracingPipeline", static_cast<bool>(obj.rayTracingPipeline));
+    p.PrintKeyBool("rayTracingPipelineShaderGroupHandleCaptureReplay",
+                   static_cast<bool>(obj.rayTracingPipelineShaderGroupHandleCaptureReplay));
+    p.PrintKeyBool("rayTracingPipelineShaderGroupHandleCaptureReplayMixed",
+                   static_cast<bool>(obj.rayTracingPipelineShaderGroupHandleCaptureReplayMixed));
+    p.PrintKeyBool("rayTracingPipelineTraceRaysIndirect", static_cast<bool>(obj.rayTracingPipelineTraceRaysIndirect));
+    p.PrintKeyBool("rayTraversalPrimitiveCulling", static_cast<bool>(obj.rayTraversalPrimitiveCulling));
+}
+void DumpVkPhysicalDeviceRayTracingPipelinePropertiesKHR(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceRayTracingPipelinePropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyValue("shaderGroupHandleSize", obj.shaderGroupHandleSize);
+    p.PrintKeyValue("maxRayRecursionDepth", obj.maxRayRecursionDepth);
+    p.PrintKeyValue("maxShaderGroupStride", obj.maxShaderGroupStride);
+    p.PrintKeyValue("shaderGroupBaseAlignment", obj.shaderGroupBaseAlignment);
+    p.PrintKeyValue("shaderGroupHandleCaptureReplaySize", obj.shaderGroupHandleCaptureReplaySize);
+    p.PrintKeyValue("maxRayDispatchInvocationCount", obj.maxRayDispatchInvocationCount);
+    p.PrintKeyValue("shaderGroupHandleAlignment", obj.shaderGroupHandleAlignment);
+    p.PrintKeyValue("maxRayHitAttributeSize", obj.maxRayHitAttributeSize);
+}
+void DumpVkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("rayTracingPositionFetch", static_cast<bool>(obj.rayTracingPositionFetch));
+}
+void DumpVkPhysicalDeviceRobustness2FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceRobustness2FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("robustBufferAccess2", static_cast<bool>(obj.robustBufferAccess2));
+    p.PrintKeyBool("robustImageAccess2", static_cast<bool>(obj.robustImageAccess2));
+    p.PrintKeyBool("nullDescriptor", static_cast<bool>(obj.nullDescriptor));
+}
+void DumpVkPhysicalDeviceRobustness2PropertiesKHR(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceRobustness2PropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyValue("robustStorageBufferAccessSizeAlignment", to_hex_str(p, obj.robustStorageBufferAccessSizeAlignment));
+    p.PrintKeyValue("robustUniformBufferAccessSizeAlignment", to_hex_str(p, obj.robustUniformBufferAccessSizeAlignment));
+}
+void DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceSampleLocationsPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    DumpVkSampleCountFlags(p, "sampleLocationSampleCounts", obj.sampleLocationSampleCounts);
+    DumpVkExtent2D(p, "maxSampleLocationGridSize", obj.maxSampleLocationGridSize);
+    {
+        ArrayWrapper arr(p, "sampleLocationCoordinateRange", 2);
+        for (uint32_t i = 0; i < 2; i++) {
+            p.PrintElement(obj.sampleLocationCoordinateRange[i]);
+        }
+    }
+    p.PrintKeyValue("sampleLocationSubPixelBits", obj.sampleLocationSubPixelBits);
+    p.PrintKeyBool("variableSampleLocations", static_cast<bool>(obj.variableSampleLocations));
+}
+void DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceSamplerFilterMinmaxProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("filterMinmaxSingleComponentFormats", static_cast<bool>(obj.filterMinmaxSingleComponentFormats));
+    p.PrintKeyBool("filterMinmaxImageComponentMapping", static_cast<bool>(obj.filterMinmaxImageComponentMapping));
+}
+void DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceSamplerYcbcrConversionFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    p.PrintKeyBool("samplerYcbcrConversion", static_cast<bool>(obj.samplerYcbcrConversion));
+}
+void DumpVkPhysicalDeviceScalarBlockLayoutFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceScalarBlockLayoutFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("scalarBlockLayout", static_cast<bool>(obj.scalarBlockLayout));
+}
+void DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("separateDepthStencilLayouts", static_cast<bool>(obj.separateDepthStencilLayouts));
+}
+void DumpVkPhysicalDeviceShader64BitIndexingFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceShader64BitIndexingFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("shader64BitIndexing", static_cast<bool>(obj.shader64BitIndexing));
+}
+void DumpVkPhysicalDeviceShaderAbortFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderAbortFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(11);
+    p.PrintKeyBool("shaderAbort", static_cast<bool>(obj.shaderAbort));
+}
+void DumpVkPhysicalDeviceShaderAbortPropertiesKHR(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceShaderAbortPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyValue("maxShaderAbortMessageSize", obj.maxShaderAbortMessageSize);
+}
+void DumpVkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(31);
+    p.PrintKeyBool("shaderBufferFloat16Atomics", static_cast<bool>(obj.shaderBufferFloat16Atomics));
+    p.PrintKeyBool("shaderBufferFloat16AtomicAdd", static_cast<bool>(obj.shaderBufferFloat16AtomicAdd));
+    p.PrintKeyBool("shaderBufferFloat16AtomicMinMax", static_cast<bool>(obj.shaderBufferFloat16AtomicMinMax));
+    p.PrintKeyBool("shaderBufferFloat32AtomicMinMax", static_cast<bool>(obj.shaderBufferFloat32AtomicMinMax));
+    p.PrintKeyBool("shaderBufferFloat64AtomicMinMax", static_cast<bool>(obj.shaderBufferFloat64AtomicMinMax));
+    p.PrintKeyBool("shaderSharedFloat16Atomics", static_cast<bool>(obj.shaderSharedFloat16Atomics));
+    p.PrintKeyBool("shaderSharedFloat16AtomicAdd", static_cast<bool>(obj.shaderSharedFloat16AtomicAdd));
+    p.PrintKeyBool("shaderSharedFloat16AtomicMinMax", static_cast<bool>(obj.shaderSharedFloat16AtomicMinMax));
+    p.PrintKeyBool("shaderSharedFloat32AtomicMinMax", static_cast<bool>(obj.shaderSharedFloat32AtomicMinMax));
+    p.PrintKeyBool("shaderSharedFloat64AtomicMinMax", static_cast<bool>(obj.shaderSharedFloat64AtomicMinMax));
+    p.PrintKeyBool("shaderImageFloat32AtomicMinMax", static_cast<bool>(obj.shaderImageFloat32AtomicMinMax));
+    p.PrintKeyBool("sparseImageFloat32AtomicMinMax", static_cast<bool>(obj.sparseImageFloat32AtomicMinMax));
+}
+void DumpVkPhysicalDeviceShaderAtomicFloatFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("shaderBufferFloat32Atomics", static_cast<bool>(obj.shaderBufferFloat32Atomics));
+    p.PrintKeyBool("shaderBufferFloat32AtomicAdd", static_cast<bool>(obj.shaderBufferFloat32AtomicAdd));
+    p.PrintKeyBool("shaderBufferFloat64Atomics", static_cast<bool>(obj.shaderBufferFloat64Atomics));
+    p.PrintKeyBool("shaderBufferFloat64AtomicAdd", static_cast<bool>(obj.shaderBufferFloat64AtomicAdd));
+    p.PrintKeyBool("shaderSharedFloat32Atomics", static_cast<bool>(obj.shaderSharedFloat32Atomics));
+    p.PrintKeyBool("shaderSharedFloat32AtomicAdd", static_cast<bool>(obj.shaderSharedFloat32AtomicAdd));
+    p.PrintKeyBool("shaderSharedFloat64Atomics", static_cast<bool>(obj.shaderSharedFloat64Atomics));
+    p.PrintKeyBool("shaderSharedFloat64AtomicAdd", static_cast<bool>(obj.shaderSharedFloat64AtomicAdd));
+    p.PrintKeyBool("shaderImageFloat32Atomics", static_cast<bool>(obj.shaderImageFloat32Atomics));
+    p.PrintKeyBool("shaderImageFloat32AtomicAdd", static_cast<bool>(obj.shaderImageFloat32AtomicAdd));
+    p.PrintKeyBool("sparseImageFloat32Atomics", static_cast<bool>(obj.sparseImageFloat32Atomics));
+    p.PrintKeyBool("sparseImageFloat32AtomicAdd", static_cast<bool>(obj.sparseImageFloat32AtomicAdd));
+}
+void DumpVkPhysicalDeviceShaderAtomicInt64Features(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderAtomicInt64Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(24);
+    p.PrintKeyBool("shaderBufferInt64Atomics", static_cast<bool>(obj.shaderBufferInt64Atomics));
+    p.PrintKeyBool("shaderSharedInt64Atomics", static_cast<bool>(obj.shaderSharedInt64Atomics));
+}
+void DumpVkPhysicalDeviceShaderBfloat16FeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderBfloat16FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(31);
+    p.PrintKeyBool("shaderBFloat16Type", static_cast<bool>(obj.shaderBFloat16Type));
+    p.PrintKeyBool("shaderBFloat16DotProduct", static_cast<bool>(obj.shaderBFloat16DotProduct));
+    p.PrintKeyBool("shaderBFloat16CooperativeMatrix", static_cast<bool>(obj.shaderBFloat16CooperativeMatrix));
+}
+void DumpVkPhysicalDeviceShaderClockFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderClockFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("shaderSubgroupClock", static_cast<bool>(obj.shaderSubgroupClock));
+    p.PrintKeyBool("shaderDeviceClock", static_cast<bool>(obj.shaderDeviceClock));
+}
+void DumpVkPhysicalDeviceShaderConstantDataFeaturesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceShaderConstantDataFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(18);
+    p.PrintKeyBool("shaderConstantData", static_cast<bool>(obj.shaderConstantData));
+}
+void DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(30);
+    p.PrintKeyBool("shaderDemoteToHelperInvocation", static_cast<bool>(obj.shaderDemoteToHelperInvocation));
+}
+void DumpVkPhysicalDeviceShaderDrawParametersFeatures(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderDrawParametersFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("shaderDrawParameters", static_cast<bool>(obj.shaderDrawParameters));
+}
+void DumpVkPhysicalDeviceShaderExpectAssumeFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceShaderExpectAssumeFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(18);
+    p.PrintKeyBool("shaderExpectAssume", static_cast<bool>(obj.shaderExpectAssume));
+}
+void DumpVkPhysicalDeviceShaderFloat16Int8Features(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderFloat16Int8Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyBool("shaderFloat16", static_cast<bool>(obj.shaderFloat16));
+    p.PrintKeyBool("shaderInt8", static_cast<bool>(obj.shaderInt8));
+}
+void DumpVkPhysicalDeviceShaderFloat8FeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderFloat8FeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("shaderFloat8", static_cast<bool>(obj.shaderFloat8));
+    p.PrintKeyBool("shaderFloat8CooperativeMatrix", static_cast<bool>(obj.shaderFloat8CooperativeMatrix));
+}
+void DumpVkPhysicalDeviceShaderFloatControls2Features(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderFloatControls2Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("shaderFloatControls2", static_cast<bool>(obj.shaderFloatControls2));
+}
+void DumpVkPhysicalDeviceShaderFmaFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderFmaFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("shaderFmaFloat16", static_cast<bool>(obj.shaderFmaFloat16));
+    p.PrintKeyBool("shaderFmaFloat32", static_cast<bool>(obj.shaderFmaFloat32));
+    p.PrintKeyBool("shaderFmaFloat64", static_cast<bool>(obj.shaderFmaFloat64));
+}
+void DumpVkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("shaderImageInt64Atomics", static_cast<bool>(obj.shaderImageInt64Atomics));
+    p.PrintKeyBool("sparseImageInt64Atomics", static_cast<bool>(obj.sparseImageInt64Atomics));
+}
+void DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceShaderIntegerDotProductFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("shaderIntegerDotProduct", static_cast<bool>(obj.shaderIntegerDotProduct));
+}
+void DumpVkPhysicalDeviceShaderIntegerDotProductProperties(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderIntegerDotProductProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(77);
+    p.PrintKeyBool("integerDotProduct8BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct8BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct8BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct8BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct8BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct8BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct4x8BitPackedUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProduct4x8BitPackedUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct4x8BitPackedSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProduct4x8BitPackedSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct4x8BitPackedMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct4x8BitPackedMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct16BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct16BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct16BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct16BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct16BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct16BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct32BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct32BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct32BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct32BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct32BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct32BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct64BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct64BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct64BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct64BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct64BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct64BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated));
+}
+void DumpVkPhysicalDeviceShaderLongVectorFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceShaderLongVectorFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(10);
+    p.PrintKeyBool("longVector", static_cast<bool>(obj.longVector));
+}
+void DumpVkPhysicalDeviceShaderLongVectorPropertiesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceShaderLongVectorPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyValue("maxVectorComponents", obj.maxVectorComponents);
+}
+void DumpVkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("shaderMaximalReconvergence", static_cast<bool>(obj.shaderMaximalReconvergence));
+}
+void DumpVkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    p.PrintKeyBool("shaderModuleIdentifier", static_cast<bool>(obj.shaderModuleIdentifier));
+}
+void DumpVkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(35);
+    p.PrintKeyValue("shaderModuleIdentifierAlgorithmUUID", obj.shaderModuleIdentifierAlgorithmUUID);
+}
+void DumpVkPhysicalDeviceShaderObjectFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderObjectFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("shaderObject", static_cast<bool>(obj.shaderObject));
+}
+void DumpVkPhysicalDeviceShaderObjectPropertiesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderObjectPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyValue("shaderBinaryUUID", obj.shaderBinaryUUID);
+    p.PrintKeyValue("shaderBinaryVersion", obj.shaderBinaryVersion);
+}
+void DumpVkPhysicalDeviceShaderQuadControlFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderQuadControlFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("shaderQuadControl", static_cast<bool>(obj.shaderQuadControl));
+}
+void DumpVkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyBool("shaderRelaxedExtendedInstruction", static_cast<bool>(obj.shaderRelaxedExtendedInstruction));
+}
+void DumpVkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("shaderReplicatedComposites", static_cast<bool>(obj.shaderReplicatedComposites));
+}
+void DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("shaderSubgroupExtendedTypes", static_cast<bool>(obj.shaderSubgroupExtendedTypes));
+}
+void DumpVkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("shaderSubgroupPartitioned", static_cast<bool>(obj.shaderSubgroupPartitioned));
+}
+void DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderSubgroupRotateFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("shaderSubgroupRotate", static_cast<bool>(obj.shaderSubgroupRotate));
+    p.PrintKeyBool("shaderSubgroupRotateClustered", static_cast<bool>(obj.shaderSubgroupRotateClustered));
+}
+void DumpVkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyBool("shaderSubgroupUniformControlFlow", static_cast<bool>(obj.shaderSubgroupUniformControlFlow));
+}
+void DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderTerminateInvocationFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("shaderTerminateInvocation", static_cast<bool>(obj.shaderTerminateInvocation));
+}
+void DumpVkPhysicalDeviceShaderTileImageFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceShaderTileImageFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyBool("shaderTileImageColorReadAccess", static_cast<bool>(obj.shaderTileImageColorReadAccess));
+    p.PrintKeyBool("shaderTileImageDepthReadAccess", static_cast<bool>(obj.shaderTileImageDepthReadAccess));
+    p.PrintKeyBool("shaderTileImageStencilReadAccess", static_cast<bool>(obj.shaderTileImageStencilReadAccess));
+}
+void DumpVkPhysicalDeviceShaderTileImagePropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderTileImagePropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(48);
+    p.PrintKeyBool("shaderTileImageCoherentReadAccelerated", static_cast<bool>(obj.shaderTileImageCoherentReadAccelerated));
+    p.PrintKeyBool("shaderTileImageReadSampleFromPixelRateInvocation",
+                   static_cast<bool>(obj.shaderTileImageReadSampleFromPixelRateInvocation));
+    p.PrintKeyBool("shaderTileImageReadFromHelperInvocation", static_cast<bool>(obj.shaderTileImageReadFromHelperInvocation));
+}
+void DumpVkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(31);
+    p.PrintKeyBool("shaderUniformBufferUnsizedArray", static_cast<bool>(obj.shaderUniformBufferUnsizedArray));
+}
+void DumpVkPhysicalDeviceShaderUntypedPointersFeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("shaderUntypedPointers", static_cast<bool>(obj.shaderUntypedPointers));
+}
+void DumpVkPhysicalDeviceSparseProperties(Printer &p, std::string name, const VkPhysicalDeviceSparseProperties &obj) {
+    if (p.Type() == OutputType::json)
+        p.ObjectStart("sparseProperties");
+    else
+        p.SetSubHeader().ObjectStart(name);
+    p.SetMinKeyWidth(40);
+    p.PrintKeyBool("residencyStandard2DBlockShape", static_cast<bool>(obj.residencyStandard2DBlockShape));
+    p.PrintKeyBool("residencyStandard2DMultisampleBlockShape", static_cast<bool>(obj.residencyStandard2DMultisampleBlockShape));
+    p.PrintKeyBool("residencyStandard3DBlockShape", static_cast<bool>(obj.residencyStandard3DBlockShape));
+    p.PrintKeyBool("residencyAlignedMipSize", static_cast<bool>(obj.residencyAlignedMipSize));
+    p.PrintKeyBool("residencyNonResidentStrict", static_cast<bool>(obj.residencyNonResidentStrict));
+    p.ObjectEnd();
+}
+void DumpVkPhysicalDeviceSubgroupProperties(Printer &p, std::string name, const VkPhysicalDeviceSubgroupProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyValue("subgroupSize", obj.subgroupSize);
+    DumpVkShaderStageFlags(p, "supportedStages", obj.supportedStages);
+    DumpVkSubgroupFeatureFlags(p, "supportedOperations", obj.supportedOperations);
+    p.PrintKeyBool("quadOperationsInAllStages", static_cast<bool>(obj.quadOperationsInAllStages));
+}
+void DumpVkPhysicalDeviceSubgroupSizeControlFeatures(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceSubgroupSizeControlFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("subgroupSizeControl", static_cast<bool>(obj.subgroupSizeControl));
+    p.PrintKeyBool("computeFullSubgroups", static_cast<bool>(obj.computeFullSubgroups));
+}
+void DumpVkPhysicalDeviceSubgroupSizeControlProperties(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceSubgroupSizeControlProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyValue("minSubgroupSize", obj.minSubgroupSize);
+    p.PrintKeyValue("maxSubgroupSize", obj.maxSubgroupSize);
+    p.PrintKeyValue("maxComputeWorkgroupSubgroups", obj.maxComputeWorkgroupSubgroups);
+    DumpVkShaderStageFlags(p, "requiredSubgroupSizeStages", obj.requiredSubgroupSizeStages);
+}
+void DumpVkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("subpassMergeFeedback", static_cast<bool>(obj.subpassMergeFeedback));
+}
+void DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("swapchainMaintenance1", static_cast<bool>(obj.swapchainMaintenance1));
+}
+void DumpVkPhysicalDeviceSynchronization2Features(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceSynchronization2Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("synchronization2", static_cast<bool>(obj.synchronization2));
+}
+void DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("texelBufferAlignment", static_cast<bool>(obj.texelBufferAlignment));
+}
+void DumpVkPhysicalDeviceTexelBufferAlignmentProperties(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceTexelBufferAlignmentProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(44);
+    p.PrintKeyValue("storageTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.storageTexelBufferOffsetAlignmentBytes));
+    p.PrintKeyBool("storageTexelBufferOffsetSingleTexelAlignment",
+                   static_cast<bool>(obj.storageTexelBufferOffsetSingleTexelAlignment));
+    p.PrintKeyValue("uniformTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.uniformTexelBufferOffsetAlignmentBytes));
+    p.PrintKeyBool("uniformTexelBufferOffsetSingleTexelAlignment",
+                   static_cast<bool>(obj.uniformTexelBufferOffsetSingleTexelAlignment));
+}
+void DumpVkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("textureCompressionASTC_3D", static_cast<bool>(obj.textureCompressionASTC_3D));
+}
+void DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceTextureCompressionASTCHDRFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("textureCompressionASTC_HDR", static_cast<bool>(obj.textureCompressionASTC_HDR));
+}
+void DumpVkPhysicalDeviceTimelineSemaphoreFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceTimelineSemaphoreFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("timelineSemaphore", static_cast<bool>(obj.timelineSemaphore));
+}
+void DumpVkPhysicalDeviceTimelineSemaphoreProperties(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceTimelineSemaphoreProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(35);
+    p.PrintKeyValue("maxTimelineSemaphoreValueDifference", obj.maxTimelineSemaphoreValueDifference);
+}
+void DumpVkPhysicalDeviceToolProperties(Printer &p, std::string name, const VkPhysicalDeviceToolProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(11);
+    p.PrintKeyString("name", obj.name);
+    p.PrintKeyString("version", obj.version);
+    DumpVkToolPurposeFlags(p, "purposes", obj.purposes);
+    p.PrintKeyString("description", obj.description);
+    p.PrintKeyString("layer", obj.layer);
+}
+void DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceTransformFeedbackFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("transformFeedback", static_cast<bool>(obj.transformFeedback));
+    p.PrintKeyBool("geometryStreams", static_cast<bool>(obj.geometryStreams));
+}
+void DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceTransformFeedbackPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(42);
+    p.PrintKeyValue("maxTransformFeedbackStreams", obj.maxTransformFeedbackStreams);
+    p.PrintKeyValue("maxTransformFeedbackBuffers", obj.maxTransformFeedbackBuffers);
+    p.PrintKeyValue("maxTransformFeedbackBufferSize", to_hex_str(p, obj.maxTransformFeedbackBufferSize));
+    p.PrintKeyValue("maxTransformFeedbackStreamDataSize", obj.maxTransformFeedbackStreamDataSize);
+    p.PrintKeyValue("maxTransformFeedbackBufferDataSize", obj.maxTransformFeedbackBufferDataSize);
+    p.PrintKeyValue("maxTransformFeedbackBufferDataStride", obj.maxTransformFeedbackBufferDataStride);
+    p.PrintKeyBool("transformFeedbackQueries", static_cast<bool>(obj.transformFeedbackQueries));
+    p.PrintKeyBool("transformFeedbackStreamsLinesTriangles", static_cast<bool>(obj.transformFeedbackStreamsLinesTriangles));
+    p.PrintKeyBool("transformFeedbackRasterizationStreamSelect", static_cast<bool>(obj.transformFeedbackRasterizationStreamSelect));
+    p.PrintKeyBool("transformFeedbackDraw", static_cast<bool>(obj.transformFeedbackDraw));
+}
+void DumpVkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(24);
+    p.PrintKeyBool("unifiedImageLayouts", static_cast<bool>(obj.unifiedImageLayouts));
+    p.PrintKeyBool("unifiedImageLayoutsVideo", static_cast<bool>(obj.unifiedImageLayoutsVideo));
+}
+void DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("uniformBufferStandardLayout", static_cast<bool>(obj.uniformBufferStandardLayout));
+}
+void DumpVkPhysicalDeviceVariablePointersFeatures(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceVariablePointersFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("variablePointersStorageBuffer", static_cast<bool>(obj.variablePointersStorageBuffer));
+    p.PrintKeyBool("variablePointers", static_cast<bool>(obj.variablePointers));
+}
+void DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceVertexAttributeDivisorFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyBool("vertexAttributeInstanceRateDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateDivisor));
+    p.PrintKeyBool("vertexAttributeInstanceRateZeroDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateZeroDivisor));
+}
+void DumpVkPhysicalDeviceVertexAttributeDivisorProperties(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceVertexAttributeDivisorProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyValue("maxVertexAttribDivisor", obj.maxVertexAttribDivisor);
+    p.PrintKeyBool("supportsNonZeroFirstInstance", static_cast<bool>(obj.supportsNonZeroFirstInstance));
+}
+void DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    p.PrintKeyValue("maxVertexAttribDivisor", obj.maxVertexAttribDivisor);
+}
+void DumpVkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("vertexAttributeRobustness", static_cast<bool>(obj.vertexAttributeRobustness));
+}
+void DumpVkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("vertexInputDynamicState", static_cast<bool>(obj.vertexInputDynamicState));
+}
+void DumpVkPhysicalDeviceVideoDecodeVP9FeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyBool("videoDecodeVP9", static_cast<bool>(obj.videoDecodeVP9));
+}
+void DumpVkPhysicalDeviceVideoEncodeAV1FeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyBool("videoEncodeAV1", static_cast<bool>(obj.videoEncodeAV1));
+}
+void DumpVkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("videoEncodeIntraRefresh", static_cast<bool>(obj.videoEncodeIntraRefresh));
+}
+void DumpVkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("videoEncodeQuantizationMap", static_cast<bool>(obj.videoEncodeQuantizationMap));
+}
+void DumpVkPhysicalDeviceVideoMaintenance1FeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceVideoMaintenance1FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("videoMaintenance1", static_cast<bool>(obj.videoMaintenance1));
+}
+void DumpVkPhysicalDeviceVideoMaintenance2FeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceVideoMaintenance2FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("videoMaintenance2", static_cast<bool>(obj.videoMaintenance2));
+}
+void DumpVkPhysicalDeviceVulkan11Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan11Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("storageBuffer16BitAccess", static_cast<bool>(obj.storageBuffer16BitAccess));
+    p.PrintKeyBool("uniformAndStorageBuffer16BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer16BitAccess));
+    p.PrintKeyBool("storagePushConstant16", static_cast<bool>(obj.storagePushConstant16));
+    p.PrintKeyBool("storageInputOutput16", static_cast<bool>(obj.storageInputOutput16));
+    p.PrintKeyBool("multiview", static_cast<bool>(obj.multiview));
+    p.PrintKeyBool("multiviewGeometryShader", static_cast<bool>(obj.multiviewGeometryShader));
+    p.PrintKeyBool("multiviewTessellationShader", static_cast<bool>(obj.multiviewTessellationShader));
+    p.PrintKeyBool("variablePointersStorageBuffer", static_cast<bool>(obj.variablePointersStorageBuffer));
+    p.PrintKeyBool("variablePointers", static_cast<bool>(obj.variablePointers));
+    p.PrintKeyBool("protectedMemory", static_cast<bool>(obj.protectedMemory));
+    p.PrintKeyBool("samplerYcbcrConversion", static_cast<bool>(obj.samplerYcbcrConversion));
+    p.PrintKeyBool("shaderDrawParameters", static_cast<bool>(obj.shaderDrawParameters));
+}
+void DumpVkPhysicalDeviceVulkan11Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan11Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyValue("deviceUUID", obj.deviceUUID);
+    p.PrintKeyValue("driverUUID", obj.driverUUID);
+    if (obj.deviceLUIDValid) {  // special case
+        p.PrintKeyValue("deviceLUID", obj.deviceLUID);
+    }
+    p.PrintKeyValue("deviceNodeMask", obj.deviceNodeMask);
+    p.PrintKeyBool("deviceLUIDValid", static_cast<bool>(obj.deviceLUIDValid));
+    p.PrintKeyValue("subgroupSize", obj.subgroupSize);
+    DumpVkShaderStageFlags(p, "subgroupSupportedStages", obj.subgroupSupportedStages);
+    DumpVkSubgroupFeatureFlags(p, "subgroupSupportedOperations", obj.subgroupSupportedOperations);
+    p.PrintKeyBool("subgroupQuadOperationsInAllStages", static_cast<bool>(obj.subgroupQuadOperationsInAllStages));
+    DumpVkPointClippingBehavior(p, "pointClippingBehavior", obj.pointClippingBehavior);
+    p.PrintKeyValue("maxMultiviewViewCount", obj.maxMultiviewViewCount);
+    p.PrintKeyValue("maxMultiviewInstanceIndex", obj.maxMultiviewInstanceIndex);
+    p.PrintKeyBool("protectedNoFault", static_cast<bool>(obj.protectedNoFault));
+    p.PrintKeyValue("maxPerSetDescriptors", obj.maxPerSetDescriptors);
+    p.PrintKeyValue("maxMemoryAllocationSize", to_hex_str(p, obj.maxMemoryAllocationSize));
+}
+void DumpVkPhysicalDeviceVulkan12Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan12Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(50);
+    p.PrintKeyBool("samplerMirrorClampToEdge", static_cast<bool>(obj.samplerMirrorClampToEdge));
+    p.PrintKeyBool("drawIndirectCount", static_cast<bool>(obj.drawIndirectCount));
+    p.PrintKeyBool("storageBuffer8BitAccess", static_cast<bool>(obj.storageBuffer8BitAccess));
+    p.PrintKeyBool("uniformAndStorageBuffer8BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer8BitAccess));
+    p.PrintKeyBool("storagePushConstant8", static_cast<bool>(obj.storagePushConstant8));
+    p.PrintKeyBool("shaderBufferInt64Atomics", static_cast<bool>(obj.shaderBufferInt64Atomics));
+    p.PrintKeyBool("shaderSharedInt64Atomics", static_cast<bool>(obj.shaderSharedInt64Atomics));
+    p.PrintKeyBool("shaderFloat16", static_cast<bool>(obj.shaderFloat16));
+    p.PrintKeyBool("shaderInt8", static_cast<bool>(obj.shaderInt8));
+    p.PrintKeyBool("descriptorIndexing", static_cast<bool>(obj.descriptorIndexing));
+    p.PrintKeyBool("shaderInputAttachmentArrayDynamicIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayDynamicIndexing));
+    p.PrintKeyBool("shaderUniformTexelBufferArrayDynamicIndexing",
+                   static_cast<bool>(obj.shaderUniformTexelBufferArrayDynamicIndexing));
+    p.PrintKeyBool("shaderStorageTexelBufferArrayDynamicIndexing",
+                   static_cast<bool>(obj.shaderStorageTexelBufferArrayDynamicIndexing));
+    p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexing",
+                   static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderUniformTexelBufferArrayNonUniformIndexing",
+                   static_cast<bool>(obj.shaderUniformTexelBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderStorageTexelBufferArrayNonUniformIndexing",
+                   static_cast<bool>(obj.shaderStorageTexelBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("descriptorBindingUniformBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingUniformBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingSampledImageUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingSampledImageUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingStorageImageUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingStorageImageUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingStorageBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingStorageBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingUniformTexelBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingUniformTexelBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingStorageTexelBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingStorageTexelBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingUpdateUnusedWhilePending", static_cast<bool>(obj.descriptorBindingUpdateUnusedWhilePending));
+    p.PrintKeyBool("descriptorBindingPartiallyBound", static_cast<bool>(obj.descriptorBindingPartiallyBound));
+    p.PrintKeyBool("descriptorBindingVariableDescriptorCount", static_cast<bool>(obj.descriptorBindingVariableDescriptorCount));
+    p.PrintKeyBool("runtimeDescriptorArray", static_cast<bool>(obj.runtimeDescriptorArray));
+    p.PrintKeyBool("samplerFilterMinmax", static_cast<bool>(obj.samplerFilterMinmax));
+    p.PrintKeyBool("scalarBlockLayout", static_cast<bool>(obj.scalarBlockLayout));
+    p.PrintKeyBool("imagelessFramebuffer", static_cast<bool>(obj.imagelessFramebuffer));
+    p.PrintKeyBool("uniformBufferStandardLayout", static_cast<bool>(obj.uniformBufferStandardLayout));
+    p.PrintKeyBool("shaderSubgroupExtendedTypes", static_cast<bool>(obj.shaderSubgroupExtendedTypes));
+    p.PrintKeyBool("separateDepthStencilLayouts", static_cast<bool>(obj.separateDepthStencilLayouts));
+    p.PrintKeyBool("hostQueryReset", static_cast<bool>(obj.hostQueryReset));
+    p.PrintKeyBool("timelineSemaphore", static_cast<bool>(obj.timelineSemaphore));
+    p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress));
+    p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay));
+    p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice));
+    p.PrintKeyBool("vulkanMemoryModel", static_cast<bool>(obj.vulkanMemoryModel));
+    p.PrintKeyBool("vulkanMemoryModelDeviceScope", static_cast<bool>(obj.vulkanMemoryModelDeviceScope));
+    p.PrintKeyBool("vulkanMemoryModelAvailabilityVisibilityChains",
+                   static_cast<bool>(obj.vulkanMemoryModelAvailabilityVisibilityChains));
+    p.PrintKeyBool("shaderOutputViewportIndex", static_cast<bool>(obj.shaderOutputViewportIndex));
+    p.PrintKeyBool("shaderOutputLayer", static_cast<bool>(obj.shaderOutputLayer));
+    p.PrintKeyBool("subgroupBroadcastDynamicId", static_cast<bool>(obj.subgroupBroadcastDynamicId));
+}
+void DumpVkPhysicalDeviceVulkan12Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan12Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(52);
+    DumpVkDriverId(p, "driverID", obj.driverID);
+    p.PrintKeyString("driverName", obj.driverName);
+    p.PrintKeyString("driverInfo", obj.driverInfo);
+    DumpVkConformanceVersion(p, "conformanceVersion", obj.conformanceVersion);
+    DumpVkShaderFloatControlsIndependence(p, "denormBehaviorIndependence", obj.denormBehaviorIndependence);
+    DumpVkShaderFloatControlsIndependence(p, "roundingModeIndependence", obj.roundingModeIndependence);
+    p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat16", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat16));
+    p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat32", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat32));
+    p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat64", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat64));
+    p.PrintKeyBool("shaderDenormPreserveFloat16", static_cast<bool>(obj.shaderDenormPreserveFloat16));
+    p.PrintKeyBool("shaderDenormPreserveFloat32", static_cast<bool>(obj.shaderDenormPreserveFloat32));
+    p.PrintKeyBool("shaderDenormPreserveFloat64", static_cast<bool>(obj.shaderDenormPreserveFloat64));
+    p.PrintKeyBool("shaderDenormFlushToZeroFloat16", static_cast<bool>(obj.shaderDenormFlushToZeroFloat16));
+    p.PrintKeyBool("shaderDenormFlushToZeroFloat32", static_cast<bool>(obj.shaderDenormFlushToZeroFloat32));
+    p.PrintKeyBool("shaderDenormFlushToZeroFloat64", static_cast<bool>(obj.shaderDenormFlushToZeroFloat64));
+    p.PrintKeyBool("shaderRoundingModeRTEFloat16", static_cast<bool>(obj.shaderRoundingModeRTEFloat16));
+    p.PrintKeyBool("shaderRoundingModeRTEFloat32", static_cast<bool>(obj.shaderRoundingModeRTEFloat32));
+    p.PrintKeyBool("shaderRoundingModeRTEFloat64", static_cast<bool>(obj.shaderRoundingModeRTEFloat64));
+    p.PrintKeyBool("shaderRoundingModeRTZFloat16", static_cast<bool>(obj.shaderRoundingModeRTZFloat16));
+    p.PrintKeyBool("shaderRoundingModeRTZFloat32", static_cast<bool>(obj.shaderRoundingModeRTZFloat32));
+    p.PrintKeyBool("shaderRoundingModeRTZFloat64", static_cast<bool>(obj.shaderRoundingModeRTZFloat64));
+    p.PrintKeyValue("maxUpdateAfterBindDescriptorsInAllPools", obj.maxUpdateAfterBindDescriptorsInAllPools);
+    p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexingNative));
+    p.PrintKeyBool("robustBufferAccessUpdateAfterBind", static_cast<bool>(obj.robustBufferAccessUpdateAfterBind));
+    p.PrintKeyBool("quadDivergentImplicitLod", static_cast<bool>(obj.quadDivergentImplicitLod));
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSamplers", obj.maxPerStageDescriptorUpdateAfterBindSamplers);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindUniformBuffers", obj.maxPerStageDescriptorUpdateAfterBindUniformBuffers);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageBuffers", obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSampledImages", obj.maxPerStageDescriptorUpdateAfterBindSampledImages);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageImages", obj.maxPerStageDescriptorUpdateAfterBindStorageImages);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInputAttachments",
+                    obj.maxPerStageDescriptorUpdateAfterBindInputAttachments);
+    p.PrintKeyValue("maxPerStageUpdateAfterBindResources", obj.maxPerStageUpdateAfterBindResources);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSamplers", obj.maxDescriptorSetUpdateAfterBindSamplers);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffers", obj.maxDescriptorSetUpdateAfterBindUniformBuffers);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffersDynamic",
+                    obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffers", obj.maxDescriptorSetUpdateAfterBindStorageBuffers);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffersDynamic",
+                    obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSampledImages", obj.maxDescriptorSetUpdateAfterBindSampledImages);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageImages", obj.maxDescriptorSetUpdateAfterBindStorageImages);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInputAttachments", obj.maxDescriptorSetUpdateAfterBindInputAttachments);
+    DumpVkResolveModeFlags(p, "supportedDepthResolveModes", obj.supportedDepthResolveModes);
+    DumpVkResolveModeFlags(p, "supportedStencilResolveModes", obj.supportedStencilResolveModes);
+    p.PrintKeyBool("independentResolveNone", static_cast<bool>(obj.independentResolveNone));
+    p.PrintKeyBool("independentResolve", static_cast<bool>(obj.independentResolve));
+    p.PrintKeyBool("filterMinmaxSingleComponentFormats", static_cast<bool>(obj.filterMinmaxSingleComponentFormats));
+    p.PrintKeyBool("filterMinmaxImageComponentMapping", static_cast<bool>(obj.filterMinmaxImageComponentMapping));
+    p.PrintKeyValue("maxTimelineSemaphoreValueDifference", obj.maxTimelineSemaphoreValueDifference);
+    DumpVkSampleCountFlags(p, "framebufferIntegerColorSampleCounts", obj.framebufferIntegerColorSampleCounts);
+}
+void DumpVkPhysicalDeviceVulkan13Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan13Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(50);
+    p.PrintKeyBool("robustImageAccess", static_cast<bool>(obj.robustImageAccess));
+    p.PrintKeyBool("inlineUniformBlock", static_cast<bool>(obj.inlineUniformBlock));
+    p.PrintKeyBool("descriptorBindingInlineUniformBlockUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingInlineUniformBlockUpdateAfterBind));
+    p.PrintKeyBool("pipelineCreationCacheControl", static_cast<bool>(obj.pipelineCreationCacheControl));
+    p.PrintKeyBool("privateData", static_cast<bool>(obj.privateData));
+    p.PrintKeyBool("shaderDemoteToHelperInvocation", static_cast<bool>(obj.shaderDemoteToHelperInvocation));
+    p.PrintKeyBool("shaderTerminateInvocation", static_cast<bool>(obj.shaderTerminateInvocation));
+    p.PrintKeyBool("subgroupSizeControl", static_cast<bool>(obj.subgroupSizeControl));
+    p.PrintKeyBool("computeFullSubgroups", static_cast<bool>(obj.computeFullSubgroups));
+    p.PrintKeyBool("synchronization2", static_cast<bool>(obj.synchronization2));
+    p.PrintKeyBool("textureCompressionASTC_HDR", static_cast<bool>(obj.textureCompressionASTC_HDR));
+    p.PrintKeyBool("shaderZeroInitializeWorkgroupMemory", static_cast<bool>(obj.shaderZeroInitializeWorkgroupMemory));
+    p.PrintKeyBool("dynamicRendering", static_cast<bool>(obj.dynamicRendering));
+    p.PrintKeyBool("shaderIntegerDotProduct", static_cast<bool>(obj.shaderIntegerDotProduct));
+    p.PrintKeyBool("maintenance4", static_cast<bool>(obj.maintenance4));
+}
+void DumpVkPhysicalDeviceVulkan13Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan13Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(77);
+    p.PrintKeyValue("minSubgroupSize", obj.minSubgroupSize);
+    p.PrintKeyValue("maxSubgroupSize", obj.maxSubgroupSize);
+    p.PrintKeyValue("maxComputeWorkgroupSubgroups", obj.maxComputeWorkgroupSubgroups);
+    DumpVkShaderStageFlags(p, "requiredSubgroupSizeStages", obj.requiredSubgroupSizeStages);
+    p.PrintKeyValue("maxInlineUniformBlockSize", obj.maxInlineUniformBlockSize);
+    p.PrintKeyValue("maxPerStageDescriptorInlineUniformBlocks", obj.maxPerStageDescriptorInlineUniformBlocks);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks",
+                    obj.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
+    p.PrintKeyValue("maxDescriptorSetInlineUniformBlocks", obj.maxDescriptorSetInlineUniformBlocks);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInlineUniformBlocks", obj.maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
+    p.PrintKeyValue("maxInlineUniformTotalSize", obj.maxInlineUniformTotalSize);
+    p.PrintKeyBool("integerDotProduct8BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct8BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct8BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct8BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct8BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct8BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct4x8BitPackedUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProduct4x8BitPackedUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct4x8BitPackedSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProduct4x8BitPackedSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct4x8BitPackedMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct4x8BitPackedMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct16BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct16BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct16BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct16BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct16BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct16BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct32BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct32BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct32BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct32BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct32BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct32BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct64BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct64BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct64BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct64BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct64BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct64BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated));
+    p.PrintKeyValue("storageTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.storageTexelBufferOffsetAlignmentBytes));
+    p.PrintKeyBool("storageTexelBufferOffsetSingleTexelAlignment",
+                   static_cast<bool>(obj.storageTexelBufferOffsetSingleTexelAlignment));
+    p.PrintKeyValue("uniformTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.uniformTexelBufferOffsetAlignmentBytes));
+    p.PrintKeyBool("uniformTexelBufferOffsetSingleTexelAlignment",
+                   static_cast<bool>(obj.uniformTexelBufferOffsetSingleTexelAlignment));
+    p.PrintKeyValue("maxBufferSize", to_hex_str(p, obj.maxBufferSize));
+}
+void DumpVkPhysicalDeviceVulkan14Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan14Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyBool("globalPriorityQuery", static_cast<bool>(obj.globalPriorityQuery));
+    p.PrintKeyBool("shaderSubgroupRotate", static_cast<bool>(obj.shaderSubgroupRotate));
+    p.PrintKeyBool("shaderSubgroupRotateClustered", static_cast<bool>(obj.shaderSubgroupRotateClustered));
+    p.PrintKeyBool("shaderFloatControls2", static_cast<bool>(obj.shaderFloatControls2));
+    p.PrintKeyBool("shaderExpectAssume", static_cast<bool>(obj.shaderExpectAssume));
+    p.PrintKeyBool("rectangularLines", static_cast<bool>(obj.rectangularLines));
+    p.PrintKeyBool("bresenhamLines", static_cast<bool>(obj.bresenhamLines));
+    p.PrintKeyBool("smoothLines", static_cast<bool>(obj.smoothLines));
+    p.PrintKeyBool("stippledRectangularLines", static_cast<bool>(obj.stippledRectangularLines));
+    p.PrintKeyBool("stippledBresenhamLines", static_cast<bool>(obj.stippledBresenhamLines));
+    p.PrintKeyBool("stippledSmoothLines", static_cast<bool>(obj.stippledSmoothLines));
+    p.PrintKeyBool("vertexAttributeInstanceRateDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateDivisor));
+    p.PrintKeyBool("vertexAttributeInstanceRateZeroDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateZeroDivisor));
+    p.PrintKeyBool("indexTypeUint8", static_cast<bool>(obj.indexTypeUint8));
+    p.PrintKeyBool("dynamicRenderingLocalRead", static_cast<bool>(obj.dynamicRenderingLocalRead));
+    p.PrintKeyBool("maintenance5", static_cast<bool>(obj.maintenance5));
+    p.PrintKeyBool("maintenance6", static_cast<bool>(obj.maintenance6));
+    p.PrintKeyBool("pipelineProtectedAccess", static_cast<bool>(obj.pipelineProtectedAccess));
+    p.PrintKeyBool("pipelineRobustness", static_cast<bool>(obj.pipelineRobustness));
+    p.PrintKeyBool("hostImageCopy", static_cast<bool>(obj.hostImageCopy));
+    p.PrintKeyBool("pushDescriptor", static_cast<bool>(obj.pushDescriptor));
+}
+void DumpVkPhysicalDeviceVulkan14Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan14Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(51);
+    p.PrintKeyValue("lineSubPixelPrecisionBits", obj.lineSubPixelPrecisionBits);
+    p.PrintKeyValue("maxVertexAttribDivisor", obj.maxVertexAttribDivisor);
+    p.PrintKeyBool("supportsNonZeroFirstInstance", static_cast<bool>(obj.supportsNonZeroFirstInstance));
+    p.PrintKeyValue("maxPushDescriptors", obj.maxPushDescriptors);
+    p.PrintKeyBool("dynamicRenderingLocalReadDepthStencilAttachments",
+                   static_cast<bool>(obj.dynamicRenderingLocalReadDepthStencilAttachments));
+    p.PrintKeyBool("dynamicRenderingLocalReadMultisampledAttachments",
+                   static_cast<bool>(obj.dynamicRenderingLocalReadMultisampledAttachments));
+    p.PrintKeyBool("earlyFragmentMultisampleCoverageAfterSampleCounting",
+                   static_cast<bool>(obj.earlyFragmentMultisampleCoverageAfterSampleCounting));
+    p.PrintKeyBool("earlyFragmentSampleMaskTestBeforeSampleCounting",
+                   static_cast<bool>(obj.earlyFragmentSampleMaskTestBeforeSampleCounting));
+    p.PrintKeyBool("depthStencilSwizzleOneSupport", static_cast<bool>(obj.depthStencilSwizzleOneSupport));
+    p.PrintKeyBool("polygonModePointSize", static_cast<bool>(obj.polygonModePointSize));
+    p.PrintKeyBool("nonStrictSinglePixelWideLinesUseParallelogram",
+                   static_cast<bool>(obj.nonStrictSinglePixelWideLinesUseParallelogram));
+    p.PrintKeyBool("nonStrictWideLinesUseParallelogram", static_cast<bool>(obj.nonStrictWideLinesUseParallelogram));
+    p.PrintKeyBool("blockTexelViewCompatibleMultipleLayers", static_cast<bool>(obj.blockTexelViewCompatibleMultipleLayers));
+    p.PrintKeyValue("maxCombinedImageSamplerDescriptorCount", obj.maxCombinedImageSamplerDescriptorCount);
+    p.PrintKeyBool("fragmentShadingRateClampCombinerInputs", static_cast<bool>(obj.fragmentShadingRateClampCombinerInputs));
+    DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessStorageBuffers", obj.defaultRobustnessStorageBuffers);
+    DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessUniformBuffers", obj.defaultRobustnessUniformBuffers);
+    DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessVertexInputs", obj.defaultRobustnessVertexInputs);
+    DumpVkPipelineRobustnessImageBehavior(p, "defaultRobustnessImages", obj.defaultRobustnessImages);
+    p.PrintKeyValue("copySrcLayoutCount", obj.copySrcLayoutCount);
+    if (obj.copySrcLayoutCount == 0 || obj.pCopySrcLayouts == nullptr) {
+        p.PrintKeyString("pCopySrcLayouts", "NULL");
+    } else {
+        ArrayWrapper arr(p, "pCopySrcLayouts", obj.copySrcLayoutCount);
+        for (uint32_t i = 0; i < obj.copySrcLayoutCount; i++) {
+            DumpVkImageLayout(p, std::to_string(i), obj.pCopySrcLayouts[i]);
+        }
+    }
+    p.PrintKeyValue("copyDstLayoutCount", obj.copyDstLayoutCount);
+    if (obj.copyDstLayoutCount == 0 || obj.pCopyDstLayouts == nullptr) {
+        p.PrintKeyString("pCopyDstLayouts", "NULL");
+    } else {
+        ArrayWrapper arr(p, "pCopyDstLayouts", obj.copyDstLayoutCount);
+        for (uint32_t i = 0; i < obj.copyDstLayoutCount; i++) {
+            DumpVkImageLayout(p, std::to_string(i), obj.pCopyDstLayouts[i]);
+        }
+    }
+    p.PrintKeyValue("optimalTilingLayoutUUID", obj.optimalTilingLayoutUUID);
+    p.PrintKeyBool("identicalMemoryTypeRequirements", static_cast<bool>(obj.identicalMemoryTypeRequirements));
+}
+void DumpVkPhysicalDeviceVulkanMemoryModelFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceVulkanMemoryModelFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(45);
+    p.PrintKeyBool("vulkanMemoryModel", static_cast<bool>(obj.vulkanMemoryModel));
+    p.PrintKeyBool("vulkanMemoryModelDeviceScope", static_cast<bool>(obj.vulkanMemoryModelDeviceScope));
+    p.PrintKeyBool("vulkanMemoryModelAvailabilityVisibilityChains",
+                   static_cast<bool>(obj.vulkanMemoryModelAvailabilityVisibilityChains));
+}
+void DumpVkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(46);
+    p.PrintKeyBool("workgroupMemoryExplicitLayout", static_cast<bool>(obj.workgroupMemoryExplicitLayout));
+    p.PrintKeyBool("workgroupMemoryExplicitLayoutScalarBlockLayout",
+                   static_cast<bool>(obj.workgroupMemoryExplicitLayoutScalarBlockLayout));
+    p.PrintKeyBool("workgroupMemoryExplicitLayout8BitAccess", static_cast<bool>(obj.workgroupMemoryExplicitLayout8BitAccess));
+    p.PrintKeyBool("workgroupMemoryExplicitLayout16BitAccess", static_cast<bool>(obj.workgroupMemoryExplicitLayout16BitAccess));
+}
+void DumpVkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("ycbcr2plane444Formats", static_cast<bool>(obj.ycbcr2plane444Formats));
+}
+void DumpVkPhysicalDeviceYcbcrImageArraysFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("ycbcrImageArrays", static_cast<bool>(obj.ycbcrImageArrays));
+}
+void DumpVkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("zeroInitializeDeviceMemory", static_cast<bool>(obj.zeroInitializeDeviceMemory));
+}
+void DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(35);
+    p.PrintKeyBool("shaderZeroInitializeWorkgroupMemory", static_cast<bool>(obj.shaderZeroInitializeWorkgroupMemory));
+}
+void DumpVkPresentTimingSurfaceCapabilitiesEXT(Printer &p, std::string name, const VkPresentTimingSurfaceCapabilitiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(30);
+    p.PrintKeyBool("presentTimingSupported", static_cast<bool>(obj.presentTimingSupported));
+    p.PrintKeyBool("presentAtAbsoluteTimeSupported", static_cast<bool>(obj.presentAtAbsoluteTimeSupported));
+    p.PrintKeyBool("presentAtRelativeTimeSupported", static_cast<bool>(obj.presentAtRelativeTimeSupported));
+    DumpVkPresentStageFlagsEXT(p, "presentStageQueries", obj.presentStageQueries);
+}
+void DumpVkQueueFamilyGlobalPriorityProperties(Printer &p, std::string name, const VkQueueFamilyGlobalPriorityProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyValue("priorityCount", obj.priorityCount);
+    ArrayWrapper arr(p, "priorities", obj.priorityCount);
+    for (uint32_t i = 0; i < obj.priorityCount; i++) {
+        if (p.Type() == OutputType::json)
+            p.PrintString(std::string("VK_") + VkQueueGlobalPriorityString(obj.priorities[i]));
+        else
+            p.PrintString(VkQueueGlobalPriorityString(obj.priorities[i]));
+    }
+}
+void DumpVkQueueFamilyOwnershipTransferPropertiesKHR(Printer &p, std::string name,
+                                                     const VkQueueFamilyOwnershipTransferPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(35);
+    p.PrintKeyValue("optimalImageTransferToQueueFamilies", obj.optimalImageTransferToQueueFamilies);
+}
+void DumpVkQueueFamilyQueryResultStatusPropertiesKHR(Printer &p, std::string name,
+                                                     const VkQueueFamilyQueryResultStatusPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(24);
+    p.PrintKeyBool("queryResultStatusSupport", static_cast<bool>(obj.queryResultStatusSupport));
+}
+void DumpVkQueueFamilyVideoPropertiesKHR(Printer &p, std::string name, const VkQueueFamilyVideoPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoCodecOperationFlagsKHR(p, "videoCodecOperations", obj.videoCodecOperations);
+}
+void DumpVkSharedPresentSurfaceCapabilitiesKHR(Printer &p, std::string name, const VkSharedPresentSurfaceCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkImageUsageFlags(p, "sharedPresentSupportedUsageFlags", obj.sharedPresentSupportedUsageFlags);
+}
+void DumpVkSubpassResolvePerformanceQueryEXT(Printer &p, std::string name, const VkSubpassResolvePerformanceQueryEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(7);
+    p.PrintKeyBool("optimal", static_cast<bool>(obj.optimal));
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+void DumpVkSurfaceCapabilitiesFullScreenExclusiveEXT(Printer &p, std::string name,
+                                                     const VkSurfaceCapabilitiesFullScreenExclusiveEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("fullScreenExclusiveSupported", static_cast<bool>(obj.fullScreenExclusiveSupported));
+}
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+void DumpVkSurfaceCapabilitiesKHR(Printer &p, std::string name, const VkSurfaceCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyValue("minImageCount", obj.minImageCount);
+    p.PrintKeyValue("maxImageCount", obj.maxImageCount);
+    DumpVkExtent2D(p, "currentExtent", obj.currentExtent);
+    DumpVkExtent2D(p, "minImageExtent", obj.minImageExtent);
+    DumpVkExtent2D(p, "maxImageExtent", obj.maxImageExtent);
+    p.PrintKeyValue("maxImageArrayLayers", obj.maxImageArrayLayers);
+    DumpVkSurfaceTransformFlagsKHR(p, "supportedTransforms", obj.supportedTransforms);
+    DumpVkSurfaceTransformFlagBitsKHR(p, "currentTransform", obj.currentTransform);
+    DumpVkCompositeAlphaFlagsKHR(p, "supportedCompositeAlpha", obj.supportedCompositeAlpha);
+    DumpVkImageUsageFlags(p, "supportedUsageFlags", obj.supportedUsageFlags);
+}
+void DumpVkSurfaceCapabilitiesPresentId2KHR(Printer &p, std::string name, const VkSurfaceCapabilitiesPresentId2KHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("presentId2Supported", static_cast<bool>(obj.presentId2Supported));
+}
+void DumpVkSurfaceCapabilitiesPresentWait2KHR(Printer &p, std::string name, const VkSurfaceCapabilitiesPresentWait2KHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("presentWait2Supported", static_cast<bool>(obj.presentWait2Supported));
+}
+void DumpVkSurfaceFormatKHR(Printer &p, std::string name, const VkSurfaceFormatKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkFormat(p, "format", obj.format);
+    DumpVkColorSpaceKHR(p, "colorSpace", obj.colorSpace);
+}
+void DumpVkSurfacePresentModeCompatibilityKHR(Printer &p, std::string name, const VkSurfacePresentModeCompatibilityKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyValue("presentModeCount", obj.presentModeCount);
+    if (obj.presentModeCount == 0 || obj.pPresentModes == nullptr) {
+        p.PrintKeyString("pPresentModes", "NULL");
+    } else {
+        ArrayWrapper arr(p, "pPresentModes", obj.presentModeCount);
+        for (uint32_t i = 0; i < obj.presentModeCount; i++) {
+            DumpVkPresentModeKHR(p, std::to_string(i), obj.pPresentModes[i]);
+        }
+    }
+}
+void DumpVkSurfacePresentScalingCapabilitiesKHR(Printer &p, std::string name, const VkSurfacePresentScalingCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkPresentScalingFlagsKHR(p, "supportedPresentScaling", obj.supportedPresentScaling);
+    DumpVkPresentGravityFlagsKHR(p, "supportedPresentGravityX", obj.supportedPresentGravityX);
+    DumpVkPresentGravityFlagsKHR(p, "supportedPresentGravityY", obj.supportedPresentGravityY);
+    DumpVkExtent2D(p, "minScaledImageExtent", obj.minScaledImageExtent);
+    DumpVkExtent2D(p, "maxScaledImageExtent", obj.maxScaledImageExtent);
+}
+void DumpVkSurfaceProtectedCapabilitiesKHR(Printer &p, std::string name, const VkSurfaceProtectedCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("supportsProtected", static_cast<bool>(obj.supportsProtected));
+}
+void DumpVkVideoCapabilitiesKHR(Printer &p, std::string name, const VkVideoCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    DumpVkVideoCapabilityFlagsKHR(p, "flags", obj.flags);
+    p.PrintKeyValue("minBitstreamBufferOffsetAlignment", to_hex_str(p, obj.minBitstreamBufferOffsetAlignment));
+    p.PrintKeyValue("minBitstreamBufferSizeAlignment", to_hex_str(p, obj.minBitstreamBufferSizeAlignment));
+    DumpVkExtent2D(p, "pictureAccessGranularity", obj.pictureAccessGranularity);
+    DumpVkExtent2D(p, "minCodedExtent", obj.minCodedExtent);
+    DumpVkExtent2D(p, "maxCodedExtent", obj.maxCodedExtent);
+    p.PrintKeyValue("maxDpbSlots", obj.maxDpbSlots);
+    p.PrintKeyValue("maxActiveReferencePictures", obj.maxActiveReferencePictures);
+    DumpVkExtensionProperties(p, "stdHeaderVersion", obj.stdHeaderVersion);
+}
+void DumpVkVideoDecodeAV1CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeAV1CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoAV1Level(p, "maxLevel", obj.maxLevel);
+}
+void DumpVkVideoDecodeAV1ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeAV1ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    DumpStdVideoAV1Profile(p, "stdProfile", obj.stdProfile);
+    p.PrintKeyBool("filmGrainSupport", static_cast<bool>(obj.filmGrainSupport));
+}
+void DumpVkVideoDecodeCapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoDecodeCapabilityFlagsKHR(p, "flags", obj.flags);
+}
+void DumpVkVideoDecodeH264CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeH264CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoH264LevelIdc(p, "maxLevelIdc", obj.maxLevelIdc);
+    DumpVkOffset2D(p, "fieldOffsetGranularity", obj.fieldOffsetGranularity);
+}
+void DumpVkVideoDecodeH264ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeH264ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoH264ProfileIdc(p, "stdProfileIdc", obj.stdProfileIdc);
+    DumpVkVideoDecodeH264PictureLayoutFlagBitsKHR(p, "pictureLayout", obj.pictureLayout);
+}
+void DumpVkVideoDecodeH265CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeH265CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoH265LevelIdc(p, "maxLevelIdc", obj.maxLevelIdc);
+}
+void DumpVkVideoDecodeH265ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeH265ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoH265ProfileIdc(p, "stdProfileIdc", obj.stdProfileIdc);
+}
+void DumpVkVideoDecodeUsageInfoKHR(Printer &p, std::string name, const VkVideoDecodeUsageInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoDecodeUsageFlagsKHR(p, "videoUsageHints", obj.videoUsageHints);
+}
+void DumpVkVideoDecodeVP9CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeVP9CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoVP9Level(p, "maxLevel", obj.maxLevel);
+}
+void DumpVkVideoDecodeVP9ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeVP9ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoVP9Profile(p, "stdProfile", obj.stdProfile);
+}
+void DumpVkVideoEncodeAV1CapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeAV1CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(45);
+    DumpVkVideoEncodeAV1CapabilityFlagsKHR(p, "flags", obj.flags);
+    DumpStdVideoAV1Level(p, "maxLevel", obj.maxLevel);
+    DumpVkExtent2D(p, "codedPictureAlignment", obj.codedPictureAlignment);
+    DumpVkExtent2D(p, "maxTiles", obj.maxTiles);
+    DumpVkExtent2D(p, "minTileSize", obj.minTileSize);
+    DumpVkExtent2D(p, "maxTileSize", obj.maxTileSize);
+    DumpVkVideoEncodeAV1SuperblockSizeFlagsKHR(p, "superblockSizes", obj.superblockSizes);
+    p.PrintKeyValue("maxSingleReferenceCount", obj.maxSingleReferenceCount);
+    p.PrintKeyValue("singleReferenceNameMask", obj.singleReferenceNameMask);
+    p.PrintKeyValue("maxUnidirectionalCompoundReferenceCount", obj.maxUnidirectionalCompoundReferenceCount);
+    p.PrintKeyValue("maxUnidirectionalCompoundGroup1ReferenceCount", obj.maxUnidirectionalCompoundGroup1ReferenceCount);
+    p.PrintKeyValue("unidirectionalCompoundReferenceNameMask", obj.unidirectionalCompoundReferenceNameMask);
+    p.PrintKeyValue("maxBidirectionalCompoundReferenceCount", obj.maxBidirectionalCompoundReferenceCount);
+    p.PrintKeyValue("maxBidirectionalCompoundGroup1ReferenceCount", obj.maxBidirectionalCompoundGroup1ReferenceCount);
+    p.PrintKeyValue("maxBidirectionalCompoundGroup2ReferenceCount", obj.maxBidirectionalCompoundGroup2ReferenceCount);
+    p.PrintKeyValue("bidirectionalCompoundReferenceNameMask", obj.bidirectionalCompoundReferenceNameMask);
+    p.PrintKeyValue("maxTemporalLayerCount", obj.maxTemporalLayerCount);
+    p.PrintKeyValue("maxSpatialLayerCount", obj.maxSpatialLayerCount);
+    p.PrintKeyValue("maxOperatingPoints", obj.maxOperatingPoints);
+    p.PrintKeyValue("minQIndex", obj.minQIndex);
+    p.PrintKeyValue("maxQIndex", obj.maxQIndex);
+    p.PrintKeyBool("prefersGopRemainingFrames", static_cast<bool>(obj.prefersGopRemainingFrames));
+    p.PrintKeyBool("requiresGopRemainingFrames", static_cast<bool>(obj.requiresGopRemainingFrames));
+    DumpVkVideoEncodeAV1StdFlagsKHR(p, "stdSyntaxFlags", obj.stdSyntaxFlags);
+}
+void DumpVkVideoEncodeAV1ProfileInfoKHR(Printer &p, std::string name, const VkVideoEncodeAV1ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoAV1Profile(p, "stdProfile", obj.stdProfile);
+}
+void DumpVkVideoEncodeAV1QuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                        const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyValue("minQIndexDelta", obj.minQIndexDelta);
+    p.PrintKeyValue("maxQIndexDelta", obj.maxQIndexDelta);
+}
+void DumpVkVideoEncodeCapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    DumpVkVideoEncodeCapabilityFlagsKHR(p, "flags", obj.flags);
+    DumpVkVideoEncodeRateControlModeFlagsKHR(p, "rateControlModes", obj.rateControlModes);
+    p.PrintKeyValue("maxRateControlLayers", obj.maxRateControlLayers);
+    p.PrintKeyValue("maxBitrate", obj.maxBitrate);
+    p.PrintKeyValue("maxQualityLevels", obj.maxQualityLevels);
+    DumpVkExtent2D(p, "encodeInputPictureGranularity", obj.encodeInputPictureGranularity);
+    DumpVkVideoEncodeFeedbackFlagsKHR(p, "supportedEncodeFeedbackFlags", obj.supportedEncodeFeedbackFlags);
+}
+void DumpVkVideoEncodeH264CapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeH264CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    DumpVkVideoEncodeH264CapabilityFlagsKHR(p, "flags", obj.flags);
+    DumpStdVideoH264LevelIdc(p, "maxLevelIdc", obj.maxLevelIdc);
+    p.PrintKeyValue("maxSliceCount", obj.maxSliceCount);
+    p.PrintKeyValue("maxPPictureL0ReferenceCount", obj.maxPPictureL0ReferenceCount);
+    p.PrintKeyValue("maxBPictureL0ReferenceCount", obj.maxBPictureL0ReferenceCount);
+    p.PrintKeyValue("maxL1ReferenceCount", obj.maxL1ReferenceCount);
+    p.PrintKeyValue("maxTemporalLayerCount", obj.maxTemporalLayerCount);
+    p.PrintKeyBool("expectDyadicTemporalLayerPattern", static_cast<bool>(obj.expectDyadicTemporalLayerPattern));
+    p.PrintKeyValue("minQp", obj.minQp);
+    p.PrintKeyValue("maxQp", obj.maxQp);
+    p.PrintKeyBool("prefersGopRemainingFrames", static_cast<bool>(obj.prefersGopRemainingFrames));
+    p.PrintKeyBool("requiresGopRemainingFrames", static_cast<bool>(obj.requiresGopRemainingFrames));
+    DumpVkVideoEncodeH264StdFlagsKHR(p, "stdSyntaxFlags", obj.stdSyntaxFlags);
+}
+void DumpVkVideoEncodeH264ProfileInfoKHR(Printer &p, std::string name, const VkVideoEncodeH264ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoH264ProfileIdc(p, "stdProfileIdc", obj.stdProfileIdc);
+}
+void DumpVkVideoEncodeH264QuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                         const VkVideoEncodeH264QuantizationMapCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(10);
+    p.PrintKeyValue("minQpDelta", obj.minQpDelta);
+    p.PrintKeyValue("maxQpDelta", obj.maxQpDelta);
+}
+void DumpVkVideoEncodeH265CapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeH265CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(35);
+    DumpVkVideoEncodeH265CapabilityFlagsKHR(p, "flags", obj.flags);
+    DumpStdVideoH265LevelIdc(p, "maxLevelIdc", obj.maxLevelIdc);
+    p.PrintKeyValue("maxSliceSegmentCount", obj.maxSliceSegmentCount);
+    DumpVkExtent2D(p, "maxTiles", obj.maxTiles);
+    DumpVkVideoEncodeH265CtbSizeFlagsKHR(p, "ctbSizes", obj.ctbSizes);
+    DumpVkVideoEncodeH265TransformBlockSizeFlagsKHR(p, "transformBlockSizes", obj.transformBlockSizes);
+    p.PrintKeyValue("maxPPictureL0ReferenceCount", obj.maxPPictureL0ReferenceCount);
+    p.PrintKeyValue("maxBPictureL0ReferenceCount", obj.maxBPictureL0ReferenceCount);
+    p.PrintKeyValue("maxL1ReferenceCount", obj.maxL1ReferenceCount);
+    p.PrintKeyValue("maxSubLayerCount", obj.maxSubLayerCount);
+    p.PrintKeyBool("expectDyadicTemporalSubLayerPattern", static_cast<bool>(obj.expectDyadicTemporalSubLayerPattern));
+    p.PrintKeyValue("minQp", obj.minQp);
+    p.PrintKeyValue("maxQp", obj.maxQp);
+    p.PrintKeyBool("prefersGopRemainingFrames", static_cast<bool>(obj.prefersGopRemainingFrames));
+    p.PrintKeyBool("requiresGopRemainingFrames", static_cast<bool>(obj.requiresGopRemainingFrames));
+    DumpVkVideoEncodeH265StdFlagsKHR(p, "stdSyntaxFlags", obj.stdSyntaxFlags);
+}
+void DumpVkVideoEncodeH265ProfileInfoKHR(Printer &p, std::string name, const VkVideoEncodeH265ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoH265ProfileIdc(p, "stdProfileIdc", obj.stdProfileIdc);
+}
+void DumpVkVideoEncodeH265QuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                         const VkVideoEncodeH265QuantizationMapCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(10);
+    p.PrintKeyValue("minQpDelta", obj.minQpDelta);
+    p.PrintKeyValue("maxQpDelta", obj.maxQpDelta);
+}
+void DumpVkVideoEncodeIntraRefreshCapabilitiesKHR(Printer &p, std::string name,
+                                                  const VkVideoEncodeIntraRefreshCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(39);
+    DumpVkVideoEncodeIntraRefreshModeFlagsKHR(p, "intraRefreshModes", obj.intraRefreshModes);
+    p.PrintKeyValue("maxIntraRefreshCycleDuration", obj.maxIntraRefreshCycleDuration);
+    p.PrintKeyValue("maxIntraRefreshActiveReferencePictures", obj.maxIntraRefreshActiveReferencePictures);
+    p.PrintKeyBool("partitionIndependentIntraRefreshRegions", static_cast<bool>(obj.partitionIndependentIntraRefreshRegions));
+    p.PrintKeyBool("nonRectangularIntraRefreshRegions", static_cast<bool>(obj.nonRectangularIntraRefreshRegions));
+}
+void DumpVkVideoEncodeProfileRgbConversionInfoVALVE(Printer &p, std::string name,
+                                                    const VkVideoEncodeProfileRgbConversionInfoVALVE &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("performEncodeRgbConversion", static_cast<bool>(obj.performEncodeRgbConversion));
+}
+void DumpVkVideoEncodeQuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                     const VkVideoEncodeQuantizationMapCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkExtent2D(p, "maxQuantizationMapExtent", obj.maxQuantizationMapExtent);
+}
+void DumpVkVideoEncodeRgbConversionCapabilitiesVALVE(Printer &p, std::string name,
+                                                     const VkVideoEncodeRgbConversionCapabilitiesVALVE &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoEncodeRgbModelConversionFlagsVALVE(p, "rgbModels", obj.rgbModels);
+    DumpVkVideoEncodeRgbRangeCompressionFlagsVALVE(p, "rgbRanges", obj.rgbRanges);
+    DumpVkVideoEncodeRgbChromaOffsetFlagsVALVE(p, "xChromaOffsets", obj.xChromaOffsets);
+    DumpVkVideoEncodeRgbChromaOffsetFlagsVALVE(p, "yChromaOffsets", obj.yChromaOffsets);
+}
+void DumpVkVideoEncodeUsageInfoKHR(Printer &p, std::string name, const VkVideoEncodeUsageInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoEncodeUsageFlagsKHR(p, "videoUsageHints", obj.videoUsageHints);
+    DumpVkVideoEncodeContentFlagsKHR(p, "videoContentHints", obj.videoContentHints);
+    DumpVkVideoEncodeTuningModeKHR(p, "tuningMode", obj.tuningMode);
+}
+void DumpVkVideoFormatAV1QuantizationMapPropertiesKHR(Printer &p, std::string name,
+                                                      const VkVideoFormatAV1QuantizationMapPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoEncodeAV1SuperblockSizeFlagsKHR(p, "compatibleSuperblockSizes", obj.compatibleSuperblockSizes);
+}
+void DumpVkVideoFormatH265QuantizationMapPropertiesKHR(Printer &p, std::string name,
+                                                       const VkVideoFormatH265QuantizationMapPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoEncodeH265CtbSizeFlagsKHR(p, "compatibleCtbSizes", obj.compatibleCtbSizes);
+}
+void DumpVkVideoFormatPropertiesKHR(Printer &p, std::string name, const VkVideoFormatPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkFormat(p, "format", obj.format);
+    DumpVkComponentMapping(p, "componentMapping", obj.componentMapping);
+    DumpVkImageCreateFlags(p, "imageCreateFlags", obj.imageCreateFlags);
+    DumpVkImageType(p, "imageType", obj.imageType);
+    DumpVkImageTiling(p, "imageTiling", obj.imageTiling);
+    DumpVkImageUsageFlags(p, "imageUsageFlags", obj.imageUsageFlags);
+}
+void DumpVkVideoFormatQuantizationMapPropertiesKHR(Printer &p, std::string name,
+                                                   const VkVideoFormatQuantizationMapPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkExtent2D(p, "quantizationMapTexelSize", obj.quantizationMapTexelSize);
+}
+void DumpVkVideoProfileInfoKHR(Printer &p, std::string name, const VkVideoProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoCodecOperationFlagBitsKHR(p, "videoCodecOperation", obj.videoCodecOperation);
+    DumpVkVideoChromaSubsamplingFlagsKHR(p, "chromaSubsampling", obj.chromaSubsampling);
+    DumpVkVideoComponentBitDepthFlagsKHR(p, "lumaBitDepth", obj.lumaBitDepth);
+    DumpVkVideoComponentBitDepthFlagsKHR(p, "chromaBitDepth", obj.chromaBitDepth);
+}
+struct phys_device_props2_chain {
+    phys_device_props2_chain() = default;
+    phys_device_props2_chain(const phys_device_props2_chain &) = delete;
+    phys_device_props2_chain &operator=(const phys_device_props2_chain &) = delete;
+    phys_device_props2_chain(phys_device_props2_chain &&) = delete;
+    phys_device_props2_chain &operator=(phys_device_props2_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkPhysicalDeviceAccelerationStructurePropertiesKHR PhysicalDeviceAccelerationStructurePropertiesKHR{};
+    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT PhysicalDeviceBlendOperationAdvancedPropertiesEXT{};
+    VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR PhysicalDeviceComputeShaderDerivativesPropertiesKHR{};
+    VkPhysicalDeviceConservativeRasterizationPropertiesEXT PhysicalDeviceConservativeRasterizationPropertiesEXT{};
+    VkPhysicalDeviceCooperativeMatrixPropertiesKHR PhysicalDeviceCooperativeMatrixPropertiesKHR{};
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR PhysicalDeviceCopyMemoryIndirectPropertiesKHR{};
+    VkPhysicalDeviceCustomBorderColorPropertiesEXT PhysicalDeviceCustomBorderColorPropertiesEXT{};
+    VkPhysicalDeviceDepthStencilResolveProperties PhysicalDeviceDepthStencilResolveProperties{};
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT{};
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT PhysicalDeviceDescriptorBufferPropertiesEXT{};
+    VkPhysicalDeviceDescriptorHeapPropertiesEXT PhysicalDeviceDescriptorHeapPropertiesEXT{};
+    VkPhysicalDeviceDescriptorHeapTensorPropertiesARM PhysicalDeviceDescriptorHeapTensorPropertiesARM{};
+    VkPhysicalDeviceDescriptorIndexingProperties PhysicalDeviceDescriptorIndexingProperties{};
+    VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT{};
+    VkPhysicalDeviceDiscardRectanglePropertiesEXT PhysicalDeviceDiscardRectanglePropertiesEXT{};
+    VkPhysicalDeviceDriverProperties PhysicalDeviceDriverProperties{};
+    VkPhysicalDeviceDrmPropertiesEXT PhysicalDeviceDrmPropertiesEXT{};
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT PhysicalDeviceExtendedDynamicState3PropertiesEXT{};
+    VkPhysicalDeviceExternalMemoryHostPropertiesEXT PhysicalDeviceExternalMemoryHostPropertiesEXT{};
+    VkPhysicalDeviceFaultPropertiesKHR PhysicalDeviceFaultPropertiesKHR{};
+    VkPhysicalDeviceFloatControlsProperties PhysicalDeviceFloatControlsProperties{};
+    VkPhysicalDeviceFragmentDensityMap2PropertiesEXT PhysicalDeviceFragmentDensityMap2PropertiesEXT{};
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT{};
+    VkPhysicalDeviceFragmentDensityMapPropertiesEXT PhysicalDeviceFragmentDensityMapPropertiesEXT{};
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR PhysicalDeviceFragmentShaderBarycentricPropertiesKHR{};
+    VkPhysicalDeviceFragmentShadingRatePropertiesKHR PhysicalDeviceFragmentShadingRatePropertiesKHR{};
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT{};
+    VkPhysicalDeviceHostImageCopyProperties PhysicalDeviceHostImageCopyProperties{};
+    std::vector<VkImageLayout> VkPhysicalDeviceHostImageCopyProperties_pCopySrcLayouts;
+    std::vector<VkImageLayout> VkPhysicalDeviceHostImageCopyProperties_pCopyDstLayouts;
+    VkPhysicalDeviceIDProperties PhysicalDeviceIDProperties{};
+    VkPhysicalDeviceInlineUniformBlockProperties PhysicalDeviceInlineUniformBlockProperties{};
+    VkPhysicalDeviceLayeredApiPropertiesListKHR PhysicalDeviceLayeredApiPropertiesListKHR{};
+    std::vector<VkPhysicalDeviceLayeredApiPropertiesKHR> VkPhysicalDeviceLayeredApiPropertiesListKHR_pLayeredApis;
+    VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT PhysicalDeviceLegacyVertexAttributesPropertiesEXT{};
+    VkPhysicalDeviceLineRasterizationProperties PhysicalDeviceLineRasterizationProperties{};
+    VkPhysicalDeviceMaintenance10PropertiesKHR PhysicalDeviceMaintenance10PropertiesKHR{};
+    VkPhysicalDeviceMaintenance3Properties PhysicalDeviceMaintenance3Properties{};
+    VkPhysicalDeviceMaintenance4Properties PhysicalDeviceMaintenance4Properties{};
+    VkPhysicalDeviceMaintenance5Properties PhysicalDeviceMaintenance5Properties{};
+    VkPhysicalDeviceMaintenance6Properties PhysicalDeviceMaintenance6Properties{};
+    VkPhysicalDeviceMaintenance7PropertiesKHR PhysicalDeviceMaintenance7PropertiesKHR{};
+    VkPhysicalDeviceMaintenance9PropertiesKHR PhysicalDeviceMaintenance9PropertiesKHR{};
+    VkPhysicalDeviceMapMemoryPlacedPropertiesEXT PhysicalDeviceMapMemoryPlacedPropertiesEXT{};
+    VkPhysicalDeviceMemoryDecompressionPropertiesEXT PhysicalDeviceMemoryDecompressionPropertiesEXT{};
+    VkPhysicalDeviceMeshShaderPropertiesEXT PhysicalDeviceMeshShaderPropertiesEXT{};
+    VkPhysicalDeviceMultiDrawPropertiesEXT PhysicalDeviceMultiDrawPropertiesEXT{};
+    VkPhysicalDeviceMultiviewProperties PhysicalDeviceMultiviewProperties{};
+    VkPhysicalDeviceNestedCommandBufferPropertiesEXT PhysicalDeviceNestedCommandBufferPropertiesEXT{};
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT PhysicalDeviceOpacityMicromapPropertiesEXT{};
+    VkPhysicalDevicePCIBusInfoPropertiesEXT PhysicalDevicePCIBusInfoPropertiesEXT{};
+    VkPhysicalDevicePerformanceQueryPropertiesKHR PhysicalDevicePerformanceQueryPropertiesKHR{};
+    VkPhysicalDevicePipelineBinaryPropertiesKHR PhysicalDevicePipelineBinaryPropertiesKHR{};
+    VkPhysicalDevicePipelineRobustnessProperties PhysicalDevicePipelineRobustnessProperties{};
+    VkPhysicalDevicePointClippingProperties PhysicalDevicePointClippingProperties{};
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VkPhysicalDevicePortabilitySubsetPropertiesKHR PhysicalDevicePortabilitySubsetPropertiesKHR{};
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+    VkPhysicalDeviceProtectedMemoryProperties PhysicalDeviceProtectedMemoryProperties{};
+    VkPhysicalDeviceProvokingVertexPropertiesEXT PhysicalDeviceProvokingVertexPropertiesEXT{};
+    VkPhysicalDevicePushDescriptorProperties PhysicalDevicePushDescriptorProperties{};
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT PhysicalDeviceRayTracingInvocationReorderPropertiesEXT{};
+    VkPhysicalDeviceRayTracingPipelinePropertiesKHR PhysicalDeviceRayTracingPipelinePropertiesKHR{};
+    VkPhysicalDeviceRobustness2PropertiesKHR PhysicalDeviceRobustness2PropertiesKHR{};
+    VkPhysicalDeviceSampleLocationsPropertiesEXT PhysicalDeviceSampleLocationsPropertiesEXT{};
+    VkPhysicalDeviceSamplerFilterMinmaxProperties PhysicalDeviceSamplerFilterMinmaxProperties{};
+    VkPhysicalDeviceShaderAbortPropertiesKHR PhysicalDeviceShaderAbortPropertiesKHR{};
+    VkPhysicalDeviceShaderIntegerDotProductProperties PhysicalDeviceShaderIntegerDotProductProperties{};
+    VkPhysicalDeviceShaderLongVectorPropertiesEXT PhysicalDeviceShaderLongVectorPropertiesEXT{};
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT PhysicalDeviceShaderModuleIdentifierPropertiesEXT{};
+    VkPhysicalDeviceShaderObjectPropertiesEXT PhysicalDeviceShaderObjectPropertiesEXT{};
+    VkPhysicalDeviceShaderTileImagePropertiesEXT PhysicalDeviceShaderTileImagePropertiesEXT{};
+    VkPhysicalDeviceSubgroupProperties PhysicalDeviceSubgroupProperties{};
+    VkPhysicalDeviceSubgroupSizeControlProperties PhysicalDeviceSubgroupSizeControlProperties{};
+    VkPhysicalDeviceTexelBufferAlignmentProperties PhysicalDeviceTexelBufferAlignmentProperties{};
+    VkPhysicalDeviceTimelineSemaphoreProperties PhysicalDeviceTimelineSemaphoreProperties{};
+    VkPhysicalDeviceTransformFeedbackPropertiesEXT PhysicalDeviceTransformFeedbackPropertiesEXT{};
+    VkPhysicalDeviceVertexAttributeDivisorProperties PhysicalDeviceVertexAttributeDivisorProperties{};
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT PhysicalDeviceVertexAttributeDivisorPropertiesEXT{};
+    VkPhysicalDeviceVulkan11Properties PhysicalDeviceVulkan11Properties{};
+    VkPhysicalDeviceVulkan12Properties PhysicalDeviceVulkan12Properties{};
+    VkPhysicalDeviceVulkan13Properties PhysicalDeviceVulkan13Properties{};
+    VkPhysicalDeviceVulkan14Properties PhysicalDeviceVulkan14Properties{};
+    std::vector<VkImageLayout> VkPhysicalDeviceVulkan14Properties_pCopySrcLayouts;
+    std::vector<VkImageLayout> VkPhysicalDeviceVulkan14Properties_pCopyDstLayouts;
+    void initialize_chain(AppInstance &inst, AppGpu &gpu, bool show_promoted_structs) noexcept {
+        PhysicalDeviceAccelerationStructurePropertiesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
+        PhysicalDeviceBlendOperationAdvancedPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
+        PhysicalDeviceComputeShaderDerivativesPropertiesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR;
+        PhysicalDeviceConservativeRasterizationPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
+        PhysicalDeviceCooperativeMatrixPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR;
+        PhysicalDeviceCopyMemoryIndirectPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR;
+        PhysicalDeviceCustomBorderColorPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
+        PhysicalDeviceDepthStencilResolveProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
+        PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
+        PhysicalDeviceDescriptorBufferPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
+        PhysicalDeviceDescriptorHeapPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT;
+        PhysicalDeviceDescriptorHeapTensorPropertiesARM.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM;
+        PhysicalDeviceDescriptorIndexingProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
+        PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT;
+        PhysicalDeviceDiscardRectanglePropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
+        PhysicalDeviceDriverProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+        PhysicalDeviceDrmPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT;
+        PhysicalDeviceExtendedDynamicState3PropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
+        PhysicalDeviceExternalMemoryHostPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
+        PhysicalDeviceFaultPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR;
+        PhysicalDeviceFloatControlsProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
+        PhysicalDeviceFragmentDensityMap2PropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
+        PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT;
+        PhysicalDeviceFragmentDensityMapPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
+        PhysicalDeviceFragmentShaderBarycentricPropertiesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
+        PhysicalDeviceFragmentShadingRatePropertiesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
+        PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
+        PhysicalDeviceHostImageCopyProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES;
+        PhysicalDeviceIDProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
+        PhysicalDeviceInlineUniformBlockProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
+        PhysicalDeviceLayeredApiPropertiesListKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR;
+        PhysicalDeviceLegacyVertexAttributesPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT;
+        PhysicalDeviceLineRasterizationProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;
+        PhysicalDeviceMaintenance10PropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR;
+        PhysicalDeviceMaintenance3Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
+        PhysicalDeviceMaintenance4Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
+        PhysicalDeviceMaintenance5Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES;
+        PhysicalDeviceMaintenance6Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES;
+        PhysicalDeviceMaintenance7PropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR;
+        PhysicalDeviceMaintenance9PropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR;
+        PhysicalDeviceMapMemoryPlacedPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT;
+        PhysicalDeviceMemoryDecompressionPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT;
+        PhysicalDeviceMeshShaderPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
+        PhysicalDeviceMultiDrawPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
+        PhysicalDeviceMultiviewProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
+        PhysicalDeviceNestedCommandBufferPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT;
+        PhysicalDeviceOpacityMicromapPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
+        PhysicalDevicePCIBusInfoPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
+        PhysicalDevicePerformanceQueryPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
+        PhysicalDevicePipelineBinaryPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR;
+        PhysicalDevicePipelineRobustnessProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES;
+        PhysicalDevicePointClippingProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        PhysicalDevicePortabilitySubsetPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        PhysicalDeviceProtectedMemoryProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
+        PhysicalDeviceProvokingVertexPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
+        PhysicalDevicePushDescriptorProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES;
+        PhysicalDeviceRayTracingInvocationReorderPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT;
+        PhysicalDeviceRayTracingPipelinePropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
+        PhysicalDeviceRobustness2PropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR;
+        PhysicalDeviceSampleLocationsPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
+        PhysicalDeviceSamplerFilterMinmaxProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
+        PhysicalDeviceShaderAbortPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR;
+        PhysicalDeviceShaderIntegerDotProductProperties.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
+        PhysicalDeviceShaderLongVectorPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT;
+        PhysicalDeviceShaderModuleIdentifierPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
+        PhysicalDeviceShaderObjectPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
+        PhysicalDeviceShaderTileImagePropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
+        PhysicalDeviceSubgroupProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
+        PhysicalDeviceSubgroupSizeControlProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
+        PhysicalDeviceTexelBufferAlignmentProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
+        PhysicalDeviceTimelineSemaphoreProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
+        PhysicalDeviceTransformFeedbackPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
+        PhysicalDeviceVertexAttributeDivisorProperties.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES;
+        PhysicalDeviceVertexAttributeDivisorPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
+        PhysicalDeviceVulkan11Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
+        PhysicalDeviceVulkan12Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
+        PhysicalDeviceVulkan13Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
+        PhysicalDeviceVulkan14Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceAccelerationStructurePropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceBlendOperationAdvancedPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceComputeShaderDerivativesPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceConservativeRasterizationPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCooperativeMatrixPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCopyMemoryIndirectPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCustomBorderColorPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDepthStencilResolveProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorBufferPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorHeapPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorHeapTensorPropertiesARM));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorIndexingProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDiscardRectanglePropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDriverProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDrmPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceExtendedDynamicState3PropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceExternalMemoryHostPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEVICE_FAULT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFaultPropertiesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFloatControlsProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentDensityMap2PropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentDensityMapPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentShaderBarycentricPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentShadingRatePropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceHostImageCopyProperties));
+        if ((inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME) ||
+             inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME) ||
+             inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceIDProperties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceInlineUniformBlockProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_7_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceLayeredApiPropertiesListKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceLegacyVertexAttributesPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME) ||
+             gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceLineRasterizationProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_10_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance10PropertiesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_3_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance3Properties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance4Properties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance5Properties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance6Properties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_7_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance7PropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_9_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance9PropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMapMemoryPlacedPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMemoryDecompressionPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MESH_SHADER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMeshShaderPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MULTI_DRAW_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMultiDrawPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMultiviewProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceNestedCommandBufferPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceOpacityMicromapPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PCI_BUS_INFO_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePCIBusInfoPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePerformanceQueryPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PIPELINE_BINARY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineBinaryPropertiesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineRobustnessProperties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_2_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePointClippingProperties));
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePortabilitySubsetPropertiesKHR));
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        if (gpu.api_version == VK_API_VERSION_1_1 || show_promoted_structs)
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceProtectedMemoryProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceProvokingVertexPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePushDescriptorProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayTracingInvocationReorderPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayTracingPipelinePropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRobustness2PropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSampleLocationsPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSamplerFilterMinmaxProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ABORT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderAbortPropertiesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderIntegerDotProductProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderLongVectorPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderModuleIdentifierPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_OBJECT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderObjectPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderTileImagePropertiesEXT));
+        if (gpu.api_version == VK_API_VERSION_1_1 || show_promoted_structs)
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSubgroupProperties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSubgroupSizeControlProperties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTexelBufferAlignmentProperties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTimelineSemaphoreProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTransformFeedbackPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVertexAttributeDivisorProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVertexAttributeDivisorPropertiesEXT));
+        if ((gpu.api_version >= VK_API_VERSION_1_2))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan11Properties));
+        if ((gpu.api_version >= VK_API_VERSION_1_2))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan12Properties));
+        if ((gpu.api_version >= VK_API_VERSION_1_3))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan13Properties));
+        if ((gpu.api_version >= VK_API_VERSION_1_4))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan14Properties));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_phys_device_props2_chain(VkPhysicalDeviceProperties2 &start, std::unique_ptr<phys_device_props2_chain> &chain,
+                                    AppInstance &inst, AppGpu &gpu, bool show_promoted_structs) {
+    chain = std::unique_ptr<phys_device_props2_chain>(new phys_device_props2_chain());
+    chain->initialize_chain(inst, gpu, show_promoted_structs);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_phys_device_props2(Printer &p, AppInstance &inst, AppGpu &gpu, bool show_promoted_structs, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR) {
+            const VkPhysicalDeviceAccelerationStructurePropertiesKHR *props =
+                (const VkPhysicalDeviceAccelerationStructurePropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceAccelerationStructurePropertiesKHR";
+            DumpVkPhysicalDeviceAccelerationStructurePropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT) {
+            const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *props =
+                (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT";
+            DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR) {
+            const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *props =
+                (const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR";
+            DumpVkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT) {
+            const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *props =
+                (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceConservativeRasterizationPropertiesEXT";
+            DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR) {
+            const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *props =
+                (const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceCooperativeMatrixPropertiesKHR";
+            DumpVkPhysicalDeviceCooperativeMatrixPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR) {
+            const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *props =
+                (const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR"
+                                   : ("VkPhysicalDeviceCopyMemoryIndirectPropertiesNV");
+            DumpVkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceCopyMemoryIndirectPropertiesNV") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(p, "VkPhysicalDeviceCopyMemoryIndirectPropertiesNV", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT) {
+            const VkPhysicalDeviceCustomBorderColorPropertiesEXT *props =
+                (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceCustomBorderColorPropertiesEXT";
+            DumpVkPhysicalDeviceCustomBorderColorPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES) {
+            const VkPhysicalDeviceDepthStencilResolveProperties *props =
+                (const VkPhysicalDeviceDepthStencilResolveProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceDepthStencilResolveProperties"
+                                                                     : ("VkPhysicalDeviceDepthStencilResolvePropertiesKHR");
+            DumpVkPhysicalDeviceDepthStencilResolveProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDepthStencilResolvePropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDepthStencilResolveProperties(p, "VkPhysicalDeviceDepthStencilResolvePropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT) {
+            const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *props =
+                (const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT";
+            DumpVkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT) {
+            const VkPhysicalDeviceDescriptorBufferPropertiesEXT *props =
+                (const VkPhysicalDeviceDescriptorBufferPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDescriptorBufferPropertiesEXT";
+            DumpVkPhysicalDeviceDescriptorBufferPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT) {
+            const VkPhysicalDeviceDescriptorHeapPropertiesEXT *props =
+                (const VkPhysicalDeviceDescriptorHeapPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDescriptorHeapPropertiesEXT";
+            DumpVkPhysicalDeviceDescriptorHeapPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM) {
+            const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM *props =
+                (const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM *)structure;
+            const char *name = "VkPhysicalDeviceDescriptorHeapTensorPropertiesARM";
+            DumpVkPhysicalDeviceDescriptorHeapTensorPropertiesARM(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES) {
+            const VkPhysicalDeviceDescriptorIndexingProperties *props =
+                (const VkPhysicalDeviceDescriptorIndexingProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceDescriptorIndexingProperties"
+                                                                     : ("VkPhysicalDeviceDescriptorIndexingPropertiesEXT");
+            DumpVkPhysicalDeviceDescriptorIndexingProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDescriptorIndexingPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDescriptorIndexingProperties(p, "VkPhysicalDeviceDescriptorIndexingPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT) {
+            const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *props =
+                (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT";
+            DumpVkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT) {
+            const VkPhysicalDeviceDiscardRectanglePropertiesEXT *props =
+                (const VkPhysicalDeviceDiscardRectanglePropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDiscardRectanglePropertiesEXT";
+            DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES) {
+            const VkPhysicalDeviceDriverProperties *props = (const VkPhysicalDeviceDriverProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceDriverProperties"
+                                                                     : ("VkPhysicalDeviceDriverPropertiesKHR");
+            DumpVkPhysicalDeviceDriverProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDriverPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDriverProperties(p, "VkPhysicalDeviceDriverPropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT) {
+            const VkPhysicalDeviceDrmPropertiesEXT *props = (const VkPhysicalDeviceDrmPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDrmPropertiesEXT";
+            DumpVkPhysicalDeviceDrmPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT) {
+            const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *props =
+                (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT";
+            DumpVkPhysicalDeviceExtendedDynamicState3PropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT) {
+            const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *props =
+                (const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceExternalMemoryHostPropertiesEXT";
+            DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR) {
+            const VkPhysicalDeviceFaultPropertiesKHR *props = (const VkPhysicalDeviceFaultPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceFaultPropertiesKHR";
+            DumpVkPhysicalDeviceFaultPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES) {
+            const VkPhysicalDeviceFloatControlsProperties *props = (const VkPhysicalDeviceFloatControlsProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceFloatControlsProperties"
+                                                                     : ("VkPhysicalDeviceFloatControlsPropertiesKHR");
+            DumpVkPhysicalDeviceFloatControlsProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFloatControlsPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceFloatControlsProperties(p, "VkPhysicalDeviceFloatControlsPropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT) {
+            const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *props =
+                (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT";
+            DumpVkPhysicalDeviceFragmentDensityMap2PropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT) {
+            const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *props =
+                (const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT"
+                                   : ("VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM");
+            DumpVkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(
+                    p, "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT) {
+            const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *props =
+                (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFragmentDensityMapPropertiesEXT";
+            DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR) {
+            const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *props =
+                (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR";
+            DumpVkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR) {
+            const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *props =
+                (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceFragmentShadingRatePropertiesKHR";
+            DumpVkPhysicalDeviceFragmentShadingRatePropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT) {
+            const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *props =
+                (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT";
+            DumpVkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES) {
+            const VkPhysicalDeviceHostImageCopyProperties *props = (const VkPhysicalDeviceHostImageCopyProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceHostImageCopyProperties"
+                                                                     : ("VkPhysicalDeviceHostImageCopyPropertiesEXT");
+            DumpVkPhysicalDeviceHostImageCopyProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceHostImageCopyPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceHostImageCopyProperties(p, "VkPhysicalDeviceHostImageCopyPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES) {
+            const VkPhysicalDeviceIDProperties *props = (const VkPhysicalDeviceIDProperties *)structure;
+            const char *name =
+                gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceIDProperties" : ("VkPhysicalDeviceIDPropertiesKHR");
+            DumpVkPhysicalDeviceIDProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceIDPropertiesKHR") != 0 &&
+                inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceIDProperties(p, "VkPhysicalDeviceIDPropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES) {
+            const VkPhysicalDeviceInlineUniformBlockProperties *props =
+                (const VkPhysicalDeviceInlineUniformBlockProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceInlineUniformBlockProperties"
+                                                                     : ("VkPhysicalDeviceInlineUniformBlockPropertiesEXT");
+            DumpVkPhysicalDeviceInlineUniformBlockProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceInlineUniformBlockPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceInlineUniformBlockProperties(p, "VkPhysicalDeviceInlineUniformBlockPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR) {
+            const VkPhysicalDeviceLayeredApiPropertiesListKHR *props =
+                (const VkPhysicalDeviceLayeredApiPropertiesListKHR *)structure;
+            const char *name = "VkPhysicalDeviceLayeredApiPropertiesListKHR";
+            DumpVkPhysicalDeviceLayeredApiPropertiesListKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT) {
+            const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *props =
+                (const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT";
+            DumpVkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES) {
+            const VkPhysicalDeviceLineRasterizationProperties *props =
+                (const VkPhysicalDeviceLineRasterizationProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4
+                                   ? "VkPhysicalDeviceLineRasterizationProperties"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceLineRasterizationPropertiesKHR"
+                                          : ("VkPhysicalDeviceLineRasterizationPropertiesEXT"));
+            DumpVkPhysicalDeviceLineRasterizationProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceLineRasterizationPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceLineRasterizationProperties(p, "VkPhysicalDeviceLineRasterizationPropertiesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceLineRasterizationPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceLineRasterizationProperties(p, "VkPhysicalDeviceLineRasterizationPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR) {
+            const VkPhysicalDeviceMaintenance10PropertiesKHR *props = (const VkPhysicalDeviceMaintenance10PropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance10PropertiesKHR";
+            DumpVkPhysicalDeviceMaintenance10PropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES) {
+            const VkPhysicalDeviceMaintenance3Properties *props = (const VkPhysicalDeviceMaintenance3Properties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceMaintenance3Properties"
+                                                                     : ("VkPhysicalDeviceMaintenance3PropertiesKHR");
+            DumpVkPhysicalDeviceMaintenance3Properties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance3PropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_3_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance3Properties(p, "VkPhysicalDeviceMaintenance3PropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES) {
+            const VkPhysicalDeviceMaintenance4Properties *props = (const VkPhysicalDeviceMaintenance4Properties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceMaintenance4Properties"
+                                                                     : ("VkPhysicalDeviceMaintenance4PropertiesKHR");
+            DumpVkPhysicalDeviceMaintenance4Properties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance4PropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance4Properties(p, "VkPhysicalDeviceMaintenance4PropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES) {
+            const VkPhysicalDeviceMaintenance5Properties *props = (const VkPhysicalDeviceMaintenance5Properties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceMaintenance5Properties"
+                                                                     : ("VkPhysicalDeviceMaintenance5PropertiesKHR");
+            DumpVkPhysicalDeviceMaintenance5Properties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance5PropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance5Properties(p, "VkPhysicalDeviceMaintenance5PropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES) {
+            const VkPhysicalDeviceMaintenance6Properties *props = (const VkPhysicalDeviceMaintenance6Properties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceMaintenance6Properties"
+                                                                     : ("VkPhysicalDeviceMaintenance6PropertiesKHR");
+            DumpVkPhysicalDeviceMaintenance6Properties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance6PropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance6Properties(p, "VkPhysicalDeviceMaintenance6PropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR) {
+            const VkPhysicalDeviceMaintenance7PropertiesKHR *props = (const VkPhysicalDeviceMaintenance7PropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance7PropertiesKHR";
+            DumpVkPhysicalDeviceMaintenance7PropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR) {
+            const VkPhysicalDeviceMaintenance9PropertiesKHR *props = (const VkPhysicalDeviceMaintenance9PropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance9PropertiesKHR";
+            DumpVkPhysicalDeviceMaintenance9PropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT) {
+            const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *props =
+                (const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT";
+            DumpVkPhysicalDeviceMapMemoryPlacedPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT) {
+            const VkPhysicalDeviceMemoryDecompressionPropertiesEXT *props =
+                (const VkPhysicalDeviceMemoryDecompressionPropertiesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceMemoryDecompressionPropertiesEXT"
+                                   : ("VkPhysicalDeviceMemoryDecompressionPropertiesNV");
+            DumpVkPhysicalDeviceMemoryDecompressionPropertiesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMemoryDecompressionPropertiesNV") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMemoryDecompressionPropertiesEXT(p, "VkPhysicalDeviceMemoryDecompressionPropertiesNV", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT) {
+            const VkPhysicalDeviceMeshShaderPropertiesEXT *props = (const VkPhysicalDeviceMeshShaderPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMeshShaderPropertiesEXT";
+            DumpVkPhysicalDeviceMeshShaderPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT) {
+            const VkPhysicalDeviceMultiDrawPropertiesEXT *props = (const VkPhysicalDeviceMultiDrawPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMultiDrawPropertiesEXT";
+            DumpVkPhysicalDeviceMultiDrawPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES) {
+            const VkPhysicalDeviceMultiviewProperties *props = (const VkPhysicalDeviceMultiviewProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceMultiviewProperties"
+                                                                     : ("VkPhysicalDeviceMultiviewPropertiesKHR");
+            DumpVkPhysicalDeviceMultiviewProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMultiviewPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMultiviewProperties(p, "VkPhysicalDeviceMultiviewPropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT) {
+            const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *props =
+                (const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceNestedCommandBufferPropertiesEXT";
+            DumpVkPhysicalDeviceNestedCommandBufferPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT) {
+            const VkPhysicalDeviceOpacityMicromapPropertiesEXT *props =
+                (const VkPhysicalDeviceOpacityMicromapPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceOpacityMicromapPropertiesEXT";
+            DumpVkPhysicalDeviceOpacityMicromapPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT) {
+            const VkPhysicalDevicePCIBusInfoPropertiesEXT *props = (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDevicePCIBusInfoPropertiesEXT";
+            DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR) {
+            const VkPhysicalDevicePerformanceQueryPropertiesKHR *props =
+                (const VkPhysicalDevicePerformanceQueryPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDevicePerformanceQueryPropertiesKHR";
+            DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR) {
+            const VkPhysicalDevicePipelineBinaryPropertiesKHR *props =
+                (const VkPhysicalDevicePipelineBinaryPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDevicePipelineBinaryPropertiesKHR";
+            DumpVkPhysicalDevicePipelineBinaryPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES) {
+            const VkPhysicalDevicePipelineRobustnessProperties *props =
+                (const VkPhysicalDevicePipelineRobustnessProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDevicePipelineRobustnessProperties"
+                                                                     : ("VkPhysicalDevicePipelineRobustnessPropertiesEXT");
+            DumpVkPhysicalDevicePipelineRobustnessProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePipelineRobustnessPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePipelineRobustnessProperties(p, "VkPhysicalDevicePipelineRobustnessPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES) {
+            const VkPhysicalDevicePointClippingProperties *props = (const VkPhysicalDevicePointClippingProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDevicePointClippingProperties"
+                                                                     : ("VkPhysicalDevicePointClippingPropertiesKHR");
+            DumpVkPhysicalDevicePointClippingProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePointClippingPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_2_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePointClippingProperties(p, "VkPhysicalDevicePointClippingPropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR &&
+            p.Type() != OutputType::json) {
+            const VkPhysicalDevicePortabilitySubsetPropertiesKHR *props =
+                (const VkPhysicalDevicePortabilitySubsetPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDevicePortabilitySubsetPropertiesKHR";
+            DumpVkPhysicalDevicePortabilitySubsetPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES) {
+            const VkPhysicalDeviceProtectedMemoryProperties *props = (const VkPhysicalDeviceProtectedMemoryProperties *)structure;
+            const char *name = "VkPhysicalDeviceProtectedMemoryProperties";
+            DumpVkPhysicalDeviceProtectedMemoryProperties(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT) {
+            const VkPhysicalDeviceProvokingVertexPropertiesEXT *props =
+                (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceProvokingVertexPropertiesEXT";
+            DumpVkPhysicalDeviceProvokingVertexPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES) {
+            const VkPhysicalDevicePushDescriptorProperties *props = (const VkPhysicalDevicePushDescriptorProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDevicePushDescriptorProperties"
+                                                                     : ("VkPhysicalDevicePushDescriptorPropertiesKHR");
+            DumpVkPhysicalDevicePushDescriptorProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePushDescriptorPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePushDescriptorProperties(p, "VkPhysicalDevicePushDescriptorPropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT) {
+            const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT *props =
+                (const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT";
+            DumpVkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR) {
+            const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *props =
+                (const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceRayTracingPipelinePropertiesKHR";
+            DumpVkPhysicalDeviceRayTracingPipelinePropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR) {
+            const VkPhysicalDeviceRobustness2PropertiesKHR *props = (const VkPhysicalDeviceRobustness2PropertiesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceRobustness2PropertiesKHR"
+                                   : ("VkPhysicalDeviceRobustness2PropertiesEXT");
+            DumpVkPhysicalDeviceRobustness2PropertiesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceRobustness2PropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceRobustness2PropertiesKHR(p, "VkPhysicalDeviceRobustness2PropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT) {
+            const VkPhysicalDeviceSampleLocationsPropertiesEXT *props =
+                (const VkPhysicalDeviceSampleLocationsPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceSampleLocationsPropertiesEXT";
+            DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES) {
+            const VkPhysicalDeviceSamplerFilterMinmaxProperties *props =
+                (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceSamplerFilterMinmaxProperties"
+                                                                     : ("VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT");
+            DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(p, "VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR) {
+            const VkPhysicalDeviceShaderAbortPropertiesKHR *props = (const VkPhysicalDeviceShaderAbortPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderAbortPropertiesKHR";
+            DumpVkPhysicalDeviceShaderAbortPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES) {
+            const VkPhysicalDeviceShaderIntegerDotProductProperties *props =
+                (const VkPhysicalDeviceShaderIntegerDotProductProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceShaderIntegerDotProductProperties"
+                                                                     : ("VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR");
+            DumpVkPhysicalDeviceShaderIntegerDotProductProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderIntegerDotProductProperties(p, "VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR",
+                                                                      *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT) {
+            const VkPhysicalDeviceShaderLongVectorPropertiesEXT *props =
+                (const VkPhysicalDeviceShaderLongVectorPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderLongVectorPropertiesEXT";
+            DumpVkPhysicalDeviceShaderLongVectorPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT) {
+            const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *props =
+                (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT";
+            DumpVkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT) {
+            const VkPhysicalDeviceShaderObjectPropertiesEXT *props = (const VkPhysicalDeviceShaderObjectPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderObjectPropertiesEXT";
+            DumpVkPhysicalDeviceShaderObjectPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT) {
+            const VkPhysicalDeviceShaderTileImagePropertiesEXT *props =
+                (const VkPhysicalDeviceShaderTileImagePropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderTileImagePropertiesEXT";
+            DumpVkPhysicalDeviceShaderTileImagePropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES) {
+            const VkPhysicalDeviceSubgroupProperties *props = (const VkPhysicalDeviceSubgroupProperties *)structure;
+            const char *name = "VkPhysicalDeviceSubgroupProperties";
+            DumpVkPhysicalDeviceSubgroupProperties(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES) {
+            const VkPhysicalDeviceSubgroupSizeControlProperties *props =
+                (const VkPhysicalDeviceSubgroupSizeControlProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceSubgroupSizeControlProperties"
+                                                                     : ("VkPhysicalDeviceSubgroupSizeControlPropertiesEXT");
+            DumpVkPhysicalDeviceSubgroupSizeControlProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSubgroupSizeControlProperties(p, "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES) {
+            const VkPhysicalDeviceTexelBufferAlignmentProperties *props =
+                (const VkPhysicalDeviceTexelBufferAlignmentProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceTexelBufferAlignmentProperties"
+                                                                     : ("VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT");
+            DumpVkPhysicalDeviceTexelBufferAlignmentProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceTexelBufferAlignmentProperties(p, "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES) {
+            const VkPhysicalDeviceTimelineSemaphoreProperties *props =
+                (const VkPhysicalDeviceTimelineSemaphoreProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceTimelineSemaphoreProperties"
+                                                                     : ("VkPhysicalDeviceTimelineSemaphorePropertiesKHR");
+            DumpVkPhysicalDeviceTimelineSemaphoreProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceTimelineSemaphorePropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceTimelineSemaphoreProperties(p, "VkPhysicalDeviceTimelineSemaphorePropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT) {
+            const VkPhysicalDeviceTransformFeedbackPropertiesEXT *props =
+                (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceTransformFeedbackPropertiesEXT";
+            DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES) {
+            const VkPhysicalDeviceVertexAttributeDivisorProperties *props =
+                (const VkPhysicalDeviceVertexAttributeDivisorProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceVertexAttributeDivisorProperties"
+                                                                     : ("VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR");
+            DumpVkPhysicalDeviceVertexAttributeDivisorProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceVertexAttributeDivisorProperties(p, "VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR",
+                                                                     *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT) {
+            const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *props =
+                (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT";
+            DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES) {
+            const VkPhysicalDeviceVulkan11Properties *props = (const VkPhysicalDeviceVulkan11Properties *)structure;
+            const char *name = "VkPhysicalDeviceVulkan11Properties";
+            DumpVkPhysicalDeviceVulkan11Properties(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES) {
+            const VkPhysicalDeviceVulkan12Properties *props = (const VkPhysicalDeviceVulkan12Properties *)structure;
+            const char *name = "VkPhysicalDeviceVulkan12Properties";
+            DumpVkPhysicalDeviceVulkan12Properties(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES) {
+            const VkPhysicalDeviceVulkan13Properties *props = (const VkPhysicalDeviceVulkan13Properties *)structure;
+            const char *name = "VkPhysicalDeviceVulkan13Properties";
+            DumpVkPhysicalDeviceVulkan13Properties(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES) {
+            const VkPhysicalDeviceVulkan14Properties *props = (const VkPhysicalDeviceVulkan14Properties *)structure;
+            const char *name = "VkPhysicalDeviceVulkan14Properties";
+            DumpVkPhysicalDeviceVulkan14Properties(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_phys_device_props2_twocall_chain_vectors(std::unique_ptr<phys_device_props2_chain> &chain) {
+    (void)chain;
+    chain->VkPhysicalDeviceHostImageCopyProperties_pCopySrcLayouts.resize(
+        chain->PhysicalDeviceHostImageCopyProperties.copySrcLayoutCount);
+    chain->PhysicalDeviceHostImageCopyProperties.pCopySrcLayouts =
+        chain->VkPhysicalDeviceHostImageCopyProperties_pCopySrcLayouts.data();
+    chain->VkPhysicalDeviceHostImageCopyProperties_pCopyDstLayouts.resize(
+        chain->PhysicalDeviceHostImageCopyProperties.copyDstLayoutCount);
+    chain->PhysicalDeviceHostImageCopyProperties.pCopyDstLayouts =
+        chain->VkPhysicalDeviceHostImageCopyProperties_pCopyDstLayouts.data();
+    chain->VkPhysicalDeviceLayeredApiPropertiesListKHR_pLayeredApis.resize(
+        chain->PhysicalDeviceLayeredApiPropertiesListKHR.layeredApiCount);
+    chain->PhysicalDeviceLayeredApiPropertiesListKHR.pLayeredApis =
+        chain->VkPhysicalDeviceLayeredApiPropertiesListKHR_pLayeredApis.data();
+    chain->VkPhysicalDeviceVulkan14Properties_pCopySrcLayouts.resize(chain->PhysicalDeviceVulkan14Properties.copySrcLayoutCount);
+    chain->PhysicalDeviceVulkan14Properties.pCopySrcLayouts = chain->VkPhysicalDeviceVulkan14Properties_pCopySrcLayouts.data();
+    chain->VkPhysicalDeviceVulkan14Properties_pCopyDstLayouts.resize(chain->PhysicalDeviceVulkan14Properties.copyDstLayoutCount);
+    chain->PhysicalDeviceVulkan14Properties.pCopyDstLayouts = chain->VkPhysicalDeviceVulkan14Properties_pCopyDstLayouts.data();
+    return true;
+}
+struct phys_device_mem_props2_chain {
+    phys_device_mem_props2_chain() = default;
+    phys_device_mem_props2_chain(const phys_device_mem_props2_chain &) = delete;
+    phys_device_mem_props2_chain &operator=(const phys_device_mem_props2_chain &) = delete;
+    phys_device_mem_props2_chain(phys_device_mem_props2_chain &&) = delete;
+    phys_device_mem_props2_chain &operator=(phys_device_mem_props2_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkPhysicalDeviceMemoryBudgetPropertiesEXT PhysicalDeviceMemoryBudgetPropertiesEXT{};
+    void initialize_chain(AppGpu &gpu) noexcept {
+        PhysicalDeviceMemoryBudgetPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_BUDGET_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMemoryBudgetPropertiesEXT));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_phys_device_mem_props2_chain(VkPhysicalDeviceMemoryProperties2 &start,
+                                        std::unique_ptr<phys_device_mem_props2_chain> &chain, AppGpu &gpu) {
+    chain = std::unique_ptr<phys_device_mem_props2_chain>(new phys_device_mem_props2_chain());
+    chain->initialize_chain(gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+bool prepare_phys_device_mem_props2_twocall_chain_vectors(std::unique_ptr<phys_device_mem_props2_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct phys_device_features2_chain {
+    phys_device_features2_chain() = default;
+    phys_device_features2_chain(const phys_device_features2_chain &) = delete;
+    phys_device_features2_chain &operator=(const phys_device_features2_chain &) = delete;
+    phys_device_features2_chain(phys_device_features2_chain &&) = delete;
+    phys_device_features2_chain &operator=(phys_device_features2_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkPhysicalDevice16BitStorageFeatures PhysicalDevice16BitStorageFeatures{};
+    VkPhysicalDevice4444FormatsFeaturesEXT PhysicalDevice4444FormatsFeaturesEXT{};
+    VkPhysicalDevice8BitStorageFeatures PhysicalDevice8BitStorageFeatures{};
+    VkPhysicalDeviceASTCDecodeFeaturesEXT PhysicalDeviceASTCDecodeFeaturesEXT{};
+    VkPhysicalDeviceAccelerationStructureFeaturesKHR PhysicalDeviceAccelerationStructureFeaturesKHR{};
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT PhysicalDeviceAddressBindingReportFeaturesEXT{};
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT{};
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT{};
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT PhysicalDeviceBlendOperationAdvancedFeaturesEXT{};
+    VkPhysicalDeviceBorderColorSwizzleFeaturesEXT PhysicalDeviceBorderColorSwizzleFeaturesEXT{};
+    VkPhysicalDeviceBufferDeviceAddressFeatures PhysicalDeviceBufferDeviceAddressFeatures{};
+    VkPhysicalDeviceBufferDeviceAddressFeaturesEXT PhysicalDeviceBufferDeviceAddressFeaturesEXT{};
+    VkPhysicalDeviceColorWriteEnableFeaturesEXT PhysicalDeviceColorWriteEnableFeaturesEXT{};
+    VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR PhysicalDeviceComputeShaderDerivativesFeaturesKHR{};
+    VkPhysicalDeviceConditionalRenderingFeaturesEXT PhysicalDeviceConditionalRenderingFeaturesEXT{};
+    VkPhysicalDeviceCooperativeMatrixFeaturesKHR PhysicalDeviceCooperativeMatrixFeaturesKHR{};
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR PhysicalDeviceCopyMemoryIndirectFeaturesKHR{};
+    VkPhysicalDeviceCustomBorderColorFeaturesEXT PhysicalDeviceCustomBorderColorFeaturesEXT{};
+    VkPhysicalDeviceCustomResolveFeaturesEXT PhysicalDeviceCustomResolveFeaturesEXT{};
+    VkPhysicalDeviceDepthBiasControlFeaturesEXT PhysicalDeviceDepthBiasControlFeaturesEXT{};
+    VkPhysicalDeviceDepthClampControlFeaturesEXT PhysicalDeviceDepthClampControlFeaturesEXT{};
+    VkPhysicalDeviceDepthClampZeroOneFeaturesKHR PhysicalDeviceDepthClampZeroOneFeaturesKHR{};
+    VkPhysicalDeviceDepthClipControlFeaturesEXT PhysicalDeviceDepthClipControlFeaturesEXT{};
+    VkPhysicalDeviceDepthClipEnableFeaturesEXT PhysicalDeviceDepthClipEnableFeaturesEXT{};
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT PhysicalDeviceDescriptorBufferFeaturesEXT{};
+    VkPhysicalDeviceDescriptorHeapFeaturesEXT PhysicalDeviceDescriptorHeapFeaturesEXT{};
+    VkPhysicalDeviceDescriptorIndexingFeatures PhysicalDeviceDescriptorIndexingFeatures{};
+    VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR PhysicalDeviceDeviceAddressCommandsFeaturesKHR{};
+    VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT{};
+    VkPhysicalDeviceDeviceMemoryReportFeaturesEXT PhysicalDeviceDeviceMemoryReportFeaturesEXT{};
+    VkPhysicalDeviceDynamicRenderingFeatures PhysicalDeviceDynamicRenderingFeatures{};
+    VkPhysicalDeviceDynamicRenderingLocalReadFeatures PhysicalDeviceDynamicRenderingLocalReadFeatures{};
+    VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT{};
+    VkPhysicalDeviceExtendedDynamicState2FeaturesEXT PhysicalDeviceExtendedDynamicState2FeaturesEXT{};
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT PhysicalDeviceExtendedDynamicState3FeaturesEXT{};
+    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT PhysicalDeviceExtendedDynamicStateFeaturesEXT{};
+    VkPhysicalDeviceFaultFeaturesEXT PhysicalDeviceFaultFeaturesEXT{};
+    VkPhysicalDeviceFaultFeaturesKHR PhysicalDeviceFaultFeaturesKHR{};
+    VkPhysicalDeviceFragmentDensityMap2FeaturesEXT PhysicalDeviceFragmentDensityMap2FeaturesEXT{};
+    VkPhysicalDeviceFragmentDensityMapFeaturesEXT PhysicalDeviceFragmentDensityMapFeaturesEXT{};
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT{};
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR PhysicalDeviceFragmentShaderBarycentricFeaturesKHR{};
+    VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT PhysicalDeviceFragmentShaderInterlockFeaturesEXT{};
+    VkPhysicalDeviceFragmentShadingRateFeaturesKHR PhysicalDeviceFragmentShadingRateFeaturesKHR{};
+    VkPhysicalDeviceFrameBoundaryFeaturesEXT PhysicalDeviceFrameBoundaryFeaturesEXT{};
+    VkPhysicalDeviceGlobalPriorityQueryFeatures PhysicalDeviceGlobalPriorityQueryFeatures{};
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT{};
+    VkPhysicalDeviceHostImageCopyFeatures PhysicalDeviceHostImageCopyFeatures{};
+    VkPhysicalDeviceHostQueryResetFeatures PhysicalDeviceHostQueryResetFeatures{};
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT PhysicalDeviceImage2DViewOf3DFeaturesEXT{};
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT PhysicalDeviceImageCompressionControlFeaturesEXT{};
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT{};
+    VkPhysicalDeviceImageRobustnessFeatures PhysicalDeviceImageRobustnessFeatures{};
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT PhysicalDeviceImageSlicedViewOf3DFeaturesEXT{};
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT PhysicalDeviceImageViewMinLodFeaturesEXT{};
+    VkPhysicalDeviceImagelessFramebufferFeatures PhysicalDeviceImagelessFramebufferFeatures{};
+    VkPhysicalDeviceIndexTypeUint8Features PhysicalDeviceIndexTypeUint8Features{};
+    VkPhysicalDeviceInlineUniformBlockFeatures PhysicalDeviceInlineUniformBlockFeatures{};
+    VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR{};
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT PhysicalDeviceLegacyDitheringFeaturesEXT{};
+    VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT PhysicalDeviceLegacyVertexAttributesFeaturesEXT{};
+    VkPhysicalDeviceLineRasterizationFeatures PhysicalDeviceLineRasterizationFeatures{};
+    VkPhysicalDeviceMaintenance10FeaturesKHR PhysicalDeviceMaintenance10FeaturesKHR{};
+    VkPhysicalDeviceMaintenance4Features PhysicalDeviceMaintenance4Features{};
+    VkPhysicalDeviceMaintenance5Features PhysicalDeviceMaintenance5Features{};
+    VkPhysicalDeviceMaintenance6Features PhysicalDeviceMaintenance6Features{};
+    VkPhysicalDeviceMaintenance7FeaturesKHR PhysicalDeviceMaintenance7FeaturesKHR{};
+    VkPhysicalDeviceMaintenance8FeaturesKHR PhysicalDeviceMaintenance8FeaturesKHR{};
+    VkPhysicalDeviceMaintenance9FeaturesKHR PhysicalDeviceMaintenance9FeaturesKHR{};
+    VkPhysicalDeviceMapMemoryPlacedFeaturesEXT PhysicalDeviceMapMemoryPlacedFeaturesEXT{};
+    VkPhysicalDeviceMemoryDecompressionFeaturesEXT PhysicalDeviceMemoryDecompressionFeaturesEXT{};
+    VkPhysicalDeviceMemoryPriorityFeaturesEXT PhysicalDeviceMemoryPriorityFeaturesEXT{};
+    VkPhysicalDeviceMeshShaderFeaturesEXT PhysicalDeviceMeshShaderFeaturesEXT{};
+    VkPhysicalDeviceMultiDrawFeaturesEXT PhysicalDeviceMultiDrawFeaturesEXT{};
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT{};
+    VkPhysicalDeviceMultiviewFeatures PhysicalDeviceMultiviewFeatures{};
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT PhysicalDeviceMutableDescriptorTypeFeaturesEXT{};
+    VkPhysicalDeviceNestedCommandBufferFeaturesEXT PhysicalDeviceNestedCommandBufferFeaturesEXT{};
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT PhysicalDeviceNonSeamlessCubeMapFeaturesEXT{};
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT PhysicalDeviceOpacityMicromapFeaturesEXT{};
+    VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT{};
+    VkPhysicalDevicePerformanceQueryFeaturesKHR PhysicalDevicePerformanceQueryFeaturesKHR{};
+    VkPhysicalDevicePipelineBinaryFeaturesKHR PhysicalDevicePipelineBinaryFeaturesKHR{};
+    VkPhysicalDevicePipelineCreationCacheControlFeatures PhysicalDevicePipelineCreationCacheControlFeatures{};
+    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR{};
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT{};
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT PhysicalDevicePipelinePropertiesFeaturesEXT{};
+    VkPhysicalDevicePipelineProtectedAccessFeatures PhysicalDevicePipelineProtectedAccessFeatures{};
+    VkPhysicalDevicePipelineRobustnessFeatures PhysicalDevicePipelineRobustnessFeatures{};
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VkPhysicalDevicePortabilitySubsetFeaturesKHR PhysicalDevicePortabilitySubsetFeaturesKHR{};
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+    VkPhysicalDevicePresentId2FeaturesKHR PhysicalDevicePresentId2FeaturesKHR{};
+    VkPhysicalDevicePresentIdFeaturesKHR PhysicalDevicePresentIdFeaturesKHR{};
+    VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR{};
+    VkPhysicalDevicePresentTimingFeaturesEXT PhysicalDevicePresentTimingFeaturesEXT{};
+    VkPhysicalDevicePresentWait2FeaturesKHR PhysicalDevicePresentWait2FeaturesKHR{};
+    VkPhysicalDevicePresentWaitFeaturesKHR PhysicalDevicePresentWaitFeaturesKHR{};
+    VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT{};
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT{};
+    VkPhysicalDevicePrivateDataFeatures PhysicalDevicePrivateDataFeatures{};
+    VkPhysicalDeviceProtectedMemoryFeatures PhysicalDeviceProtectedMemoryFeatures{};
+    VkPhysicalDeviceProvokingVertexFeaturesEXT PhysicalDeviceProvokingVertexFeaturesEXT{};
+    VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT PhysicalDeviceRGBA10X6FormatsFeaturesEXT{};
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT{};
+    VkPhysicalDeviceRayQueryFeaturesKHR PhysicalDeviceRayQueryFeaturesKHR{};
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT PhysicalDeviceRayTracingInvocationReorderFeaturesEXT{};
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR PhysicalDeviceRayTracingMaintenance1FeaturesKHR{};
+    VkPhysicalDeviceRayTracingPipelineFeaturesKHR PhysicalDeviceRayTracingPipelineFeaturesKHR{};
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR PhysicalDeviceRayTracingPositionFetchFeaturesKHR{};
+    VkPhysicalDeviceRobustness2FeaturesKHR PhysicalDeviceRobustness2FeaturesKHR{};
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures PhysicalDeviceSamplerYcbcrConversionFeatures{};
+    VkPhysicalDeviceScalarBlockLayoutFeatures PhysicalDeviceScalarBlockLayoutFeatures{};
+    VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures PhysicalDeviceSeparateDepthStencilLayoutsFeatures{};
+    VkPhysicalDeviceShader64BitIndexingFeaturesEXT PhysicalDeviceShader64BitIndexingFeaturesEXT{};
+    VkPhysicalDeviceShaderAbortFeaturesKHR PhysicalDeviceShaderAbortFeaturesKHR{};
+    VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT PhysicalDeviceShaderAtomicFloat2FeaturesEXT{};
+    VkPhysicalDeviceShaderAtomicFloatFeaturesEXT PhysicalDeviceShaderAtomicFloatFeaturesEXT{};
+    VkPhysicalDeviceShaderAtomicInt64Features PhysicalDeviceShaderAtomicInt64Features{};
+    VkPhysicalDeviceShaderBfloat16FeaturesKHR PhysicalDeviceShaderBfloat16FeaturesKHR{};
+    VkPhysicalDeviceShaderClockFeaturesKHR PhysicalDeviceShaderClockFeaturesKHR{};
+    VkPhysicalDeviceShaderConstantDataFeaturesKHR PhysicalDeviceShaderConstantDataFeaturesKHR{};
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures PhysicalDeviceShaderDemoteToHelperInvocationFeatures{};
+    VkPhysicalDeviceShaderDrawParametersFeatures PhysicalDeviceShaderDrawParametersFeatures{};
+    VkPhysicalDeviceShaderExpectAssumeFeatures PhysicalDeviceShaderExpectAssumeFeatures{};
+    VkPhysicalDeviceShaderFloat16Int8Features PhysicalDeviceShaderFloat16Int8Features{};
+    VkPhysicalDeviceShaderFloat8FeaturesEXT PhysicalDeviceShaderFloat8FeaturesEXT{};
+    VkPhysicalDeviceShaderFloatControls2Features PhysicalDeviceShaderFloatControls2Features{};
+    VkPhysicalDeviceShaderFmaFeaturesKHR PhysicalDeviceShaderFmaFeaturesKHR{};
+    VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT PhysicalDeviceShaderImageAtomicInt64FeaturesEXT{};
+    VkPhysicalDeviceShaderIntegerDotProductFeatures PhysicalDeviceShaderIntegerDotProductFeatures{};
+    char VkPhysicalDeviceShaderIntegerDotProductFeatures_padding[64];
+    VkPhysicalDeviceShaderLongVectorFeaturesEXT PhysicalDeviceShaderLongVectorFeaturesEXT{};
+    VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR{};
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT PhysicalDeviceShaderModuleIdentifierFeaturesEXT{};
+    VkPhysicalDeviceShaderObjectFeaturesEXT PhysicalDeviceShaderObjectFeaturesEXT{};
+    VkPhysicalDeviceShaderQuadControlFeaturesKHR PhysicalDeviceShaderQuadControlFeaturesKHR{};
+    VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR{};
+    VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT PhysicalDeviceShaderReplicatedCompositesFeaturesEXT{};
+    VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures PhysicalDeviceShaderSubgroupExtendedTypesFeatures{};
+    VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT{};
+    VkPhysicalDeviceShaderSubgroupRotateFeatures PhysicalDeviceShaderSubgroupRotateFeatures{};
+    VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{};
+    VkPhysicalDeviceShaderTerminateInvocationFeatures PhysicalDeviceShaderTerminateInvocationFeatures{};
+    VkPhysicalDeviceShaderTileImageFeaturesEXT PhysicalDeviceShaderTileImageFeaturesEXT{};
+    VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT{};
+    VkPhysicalDeviceShaderUntypedPointersFeaturesKHR PhysicalDeviceShaderUntypedPointersFeaturesKHR{};
+    VkPhysicalDeviceSubgroupSizeControlFeatures PhysicalDeviceSubgroupSizeControlFeatures{};
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT PhysicalDeviceSubpassMergeFeedbackFeaturesEXT{};
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR PhysicalDeviceSwapchainMaintenance1FeaturesKHR{};
+    VkPhysicalDeviceSynchronization2Features PhysicalDeviceSynchronization2Features{};
+    VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT PhysicalDeviceTexelBufferAlignmentFeaturesEXT{};
+    VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT PhysicalDeviceTextureCompressionASTC3DFeaturesEXT{};
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures PhysicalDeviceTextureCompressionASTCHDRFeatures{};
+    VkPhysicalDeviceTimelineSemaphoreFeatures PhysicalDeviceTimelineSemaphoreFeatures{};
+    VkPhysicalDeviceTransformFeedbackFeaturesEXT PhysicalDeviceTransformFeedbackFeaturesEXT{};
+    VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR PhysicalDeviceUnifiedImageLayoutsFeaturesKHR{};
+    VkPhysicalDeviceUniformBufferStandardLayoutFeatures PhysicalDeviceUniformBufferStandardLayoutFeatures{};
+    VkPhysicalDeviceVariablePointersFeatures PhysicalDeviceVariablePointersFeatures{};
+    VkPhysicalDeviceVertexAttributeDivisorFeatures PhysicalDeviceVertexAttributeDivisorFeatures{};
+    VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT PhysicalDeviceVertexAttributeRobustnessFeaturesEXT{};
+    VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT PhysicalDeviceVertexInputDynamicStateFeaturesEXT{};
+    VkPhysicalDeviceVideoDecodeVP9FeaturesKHR PhysicalDeviceVideoDecodeVP9FeaturesKHR{};
+    VkPhysicalDeviceVideoEncodeAV1FeaturesKHR PhysicalDeviceVideoEncodeAV1FeaturesKHR{};
+    VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR{};
+    VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR{};
+    VkPhysicalDeviceVideoMaintenance1FeaturesKHR PhysicalDeviceVideoMaintenance1FeaturesKHR{};
+    VkPhysicalDeviceVideoMaintenance2FeaturesKHR PhysicalDeviceVideoMaintenance2FeaturesKHR{};
+    VkPhysicalDeviceVulkan11Features PhysicalDeviceVulkan11Features{};
+    VkPhysicalDeviceVulkan12Features PhysicalDeviceVulkan12Features{};
+    VkPhysicalDeviceVulkan13Features PhysicalDeviceVulkan13Features{};
+    VkPhysicalDeviceVulkan14Features PhysicalDeviceVulkan14Features{};
+    VkPhysicalDeviceVulkanMemoryModelFeatures PhysicalDeviceVulkanMemoryModelFeatures{};
+    VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR{};
+    VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT{};
+    VkPhysicalDeviceYcbcrImageArraysFeaturesEXT PhysicalDeviceYcbcrImageArraysFeaturesEXT{};
+    VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT{};
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures{};
+    void initialize_chain(AppGpu &gpu, bool show_promoted_structs) noexcept {
+        PhysicalDevice16BitStorageFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
+        PhysicalDevice4444FormatsFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
+        PhysicalDevice8BitStorageFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
+        PhysicalDeviceASTCDecodeFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
+        PhysicalDeviceAccelerationStructureFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
+        PhysicalDeviceAddressBindingReportFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
+        PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
+        PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
+        PhysicalDeviceBlendOperationAdvancedFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
+        PhysicalDeviceBorderColorSwizzleFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
+        PhysicalDeviceBufferDeviceAddressFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
+        PhysicalDeviceBufferDeviceAddressFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
+        PhysicalDeviceColorWriteEnableFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
+        PhysicalDeviceComputeShaderDerivativesFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
+        PhysicalDeviceConditionalRenderingFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
+        PhysicalDeviceCooperativeMatrixFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
+        PhysicalDeviceCopyMemoryIndirectFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR;
+        PhysicalDeviceCustomBorderColorFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
+        PhysicalDeviceCustomResolveFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT;
+        PhysicalDeviceDepthBiasControlFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
+        PhysicalDeviceDepthClampControlFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
+        PhysicalDeviceDepthClampZeroOneFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
+        PhysicalDeviceDepthClipControlFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
+        PhysicalDeviceDepthClipEnableFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
+        PhysicalDeviceDescriptorBufferFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
+        PhysicalDeviceDescriptorHeapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT;
+        PhysicalDeviceDescriptorIndexingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
+        PhysicalDeviceDeviceAddressCommandsFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR;
+        PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
+        PhysicalDeviceDeviceMemoryReportFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT;
+        PhysicalDeviceDynamicRenderingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
+        PhysicalDeviceDynamicRenderingLocalReadFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
+        PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
+        PhysicalDeviceExtendedDynamicState2FeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
+        PhysicalDeviceExtendedDynamicState3FeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
+        PhysicalDeviceExtendedDynamicStateFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
+        PhysicalDeviceFaultFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
+        PhysicalDeviceFaultFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR;
+        PhysicalDeviceFragmentDensityMap2FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
+        PhysicalDeviceFragmentDensityMapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
+        PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT;
+        PhysicalDeviceFragmentShaderBarycentricFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
+        PhysicalDeviceFragmentShaderInterlockFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
+        PhysicalDeviceFragmentShadingRateFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
+        PhysicalDeviceFrameBoundaryFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT;
+        PhysicalDeviceGlobalPriorityQueryFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
+        PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
+        PhysicalDeviceHostImageCopyFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
+        PhysicalDeviceHostQueryResetFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
+        PhysicalDeviceImage2DViewOf3DFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
+        PhysicalDeviceImageCompressionControlFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
+        PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
+        PhysicalDeviceImageRobustnessFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
+        PhysicalDeviceImageSlicedViewOf3DFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
+        PhysicalDeviceImageViewMinLodFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
+        PhysicalDeviceImagelessFramebufferFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
+        PhysicalDeviceIndexTypeUint8Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
+        PhysicalDeviceInlineUniformBlockFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
+        PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR;
+        PhysicalDeviceLegacyDitheringFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
+        PhysicalDeviceLegacyVertexAttributesFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT;
+        PhysicalDeviceLineRasterizationFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
+        PhysicalDeviceMaintenance10FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR;
+        PhysicalDeviceMaintenance4Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
+        PhysicalDeviceMaintenance5Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
+        PhysicalDeviceMaintenance6Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
+        PhysicalDeviceMaintenance7FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR;
+        PhysicalDeviceMaintenance8FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR;
+        PhysicalDeviceMaintenance9FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR;
+        PhysicalDeviceMapMemoryPlacedFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
+        PhysicalDeviceMemoryDecompressionFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT;
+        PhysicalDeviceMemoryPriorityFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
+        PhysicalDeviceMeshShaderFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
+        PhysicalDeviceMultiDrawFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
+        PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
+        PhysicalDeviceMultiviewFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
+        PhysicalDeviceMutableDescriptorTypeFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
+        PhysicalDeviceNestedCommandBufferFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT;
+        PhysicalDeviceNonSeamlessCubeMapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
+        PhysicalDeviceOpacityMicromapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
+        PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
+        PhysicalDevicePerformanceQueryFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
+        PhysicalDevicePipelineBinaryFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR;
+        PhysicalDevicePipelineCreationCacheControlFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
+        PhysicalDevicePipelineExecutablePropertiesFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
+        PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
+        PhysicalDevicePipelinePropertiesFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
+        PhysicalDevicePipelineProtectedAccessFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
+        PhysicalDevicePipelineRobustnessFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        PhysicalDevicePortabilitySubsetFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        PhysicalDevicePresentId2FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR;
+        PhysicalDevicePresentIdFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
+        PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR;
+        PhysicalDevicePresentTimingFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT;
+        PhysicalDevicePresentWait2FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR;
+        PhysicalDevicePresentWaitFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
+        PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
+        PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
+        PhysicalDevicePrivateDataFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
+        PhysicalDeviceProtectedMemoryFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
+        PhysicalDeviceProvokingVertexFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
+        PhysicalDeviceRGBA10X6FormatsFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
+        PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
+        PhysicalDeviceRayQueryFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
+        PhysicalDeviceRayTracingInvocationReorderFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT;
+        PhysicalDeviceRayTracingMaintenance1FeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
+        PhysicalDeviceRayTracingPipelineFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
+        PhysicalDeviceRayTracingPositionFetchFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
+        PhysicalDeviceRobustness2FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
+        PhysicalDeviceSamplerYcbcrConversionFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
+        PhysicalDeviceScalarBlockLayoutFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
+        PhysicalDeviceSeparateDepthStencilLayoutsFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
+        PhysicalDeviceShader64BitIndexingFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT;
+        PhysicalDeviceShaderAbortFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR;
+        PhysicalDeviceShaderAtomicFloat2FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
+        PhysicalDeviceShaderAtomicFloatFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
+        PhysicalDeviceShaderAtomicInt64Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
+        PhysicalDeviceShaderBfloat16FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR;
+        PhysicalDeviceShaderClockFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
+        PhysicalDeviceShaderConstantDataFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR;
+        PhysicalDeviceShaderDemoteToHelperInvocationFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
+        PhysicalDeviceShaderDrawParametersFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
+        PhysicalDeviceShaderExpectAssumeFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
+        PhysicalDeviceShaderFloat16Int8Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
+        PhysicalDeviceShaderFloat8FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT;
+        PhysicalDeviceShaderFloatControls2Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
+        PhysicalDeviceShaderFmaFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR;
+        PhysicalDeviceShaderImageAtomicInt64FeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
+        PhysicalDeviceShaderIntegerDotProductFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
+        PhysicalDeviceShaderLongVectorFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT;
+        PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR;
+        PhysicalDeviceShaderModuleIdentifierFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
+        PhysicalDeviceShaderObjectFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
+        PhysicalDeviceShaderQuadControlFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR;
+        PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR;
+        PhysicalDeviceShaderReplicatedCompositesFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT;
+        PhysicalDeviceShaderSubgroupExtendedTypesFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
+        PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT;
+        PhysicalDeviceShaderSubgroupRotateFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
+        PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
+        PhysicalDeviceShaderTerminateInvocationFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
+        PhysicalDeviceShaderTileImageFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
+        PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT;
+        PhysicalDeviceShaderUntypedPointersFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR;
+        PhysicalDeviceSubgroupSizeControlFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
+        PhysicalDeviceSubpassMergeFeedbackFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
+        PhysicalDeviceSwapchainMaintenance1FeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
+        PhysicalDeviceSynchronization2Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
+        PhysicalDeviceTexelBufferAlignmentFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
+        PhysicalDeviceTextureCompressionASTC3DFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT;
+        PhysicalDeviceTextureCompressionASTCHDRFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
+        PhysicalDeviceTimelineSemaphoreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
+        PhysicalDeviceTransformFeedbackFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
+        PhysicalDeviceUnifiedImageLayoutsFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR;
+        PhysicalDeviceUniformBufferStandardLayoutFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
+        PhysicalDeviceVariablePointersFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
+        PhysicalDeviceVertexAttributeDivisorFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
+        PhysicalDeviceVertexAttributeRobustnessFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT;
+        PhysicalDeviceVertexInputDynamicStateFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
+        PhysicalDeviceVideoDecodeVP9FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR;
+        PhysicalDeviceVideoEncodeAV1FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR;
+        PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR;
+        PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR;
+        PhysicalDeviceVideoMaintenance1FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR;
+        PhysicalDeviceVideoMaintenance2FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR;
+        PhysicalDeviceVulkan11Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
+        PhysicalDeviceVulkan12Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
+        PhysicalDeviceVulkan13Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
+        PhysicalDeviceVulkan14Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES;
+        PhysicalDeviceVulkanMemoryModelFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
+        PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
+        PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
+        PhysicalDeviceYcbcrImageArraysFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
+        PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT;
+        PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_16BIT_STORAGE_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevice16BitStorageFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_4444_FORMATS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevice4444FormatsFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_8BIT_STORAGE_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevice8BitStorageFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceASTCDecodeFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceAccelerationStructureFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceAddressBindingReportFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceBlendOperationAdvancedFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceBorderColorSwizzleFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceBufferDeviceAddressFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceBufferDeviceAddressFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceColorWriteEnableFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceComputeShaderDerivativesFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceConditionalRenderingFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCooperativeMatrixFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCopyMemoryIndirectFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCustomBorderColorFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CUSTOM_RESOLVE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCustomResolveFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDepthBiasControlFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDepthClampControlFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDepthClampZeroOneFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDepthClipControlFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDepthClipEnableFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorBufferFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorHeapFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorIndexingFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEVICE_ADDRESS_COMMANDS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDeviceAddressCommandsFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDeviceMemoryReportFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDynamicRenderingFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDynamicRenderingLocalReadFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceExtendedDynamicState2FeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceExtendedDynamicState3FeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceExtendedDynamicStateFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_FAULT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFaultFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEVICE_FAULT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFaultFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentDensityMap2FeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentDensityMapFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentShaderBarycentricFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentShaderInterlockFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentShadingRateFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFrameBoundaryFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME) ||
+             gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceGlobalPriorityQueryFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceHostImageCopyFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceHostQueryResetFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImage2DViewOf3DFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageCompressionControlFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageRobustnessFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageSlicedViewOf3DFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageViewMinLodFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImagelessFramebufferFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME) ||
+             gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceIndexTypeUint8Features));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceInlineUniformBlockFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LEGACY_DITHERING_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceLegacyDitheringFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceLegacyVertexAttributesFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME) ||
+             gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceLineRasterizationFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_10_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance10FeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance4Features));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance5Features));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance6Features));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_7_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance7FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_8_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance8FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_9_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance9FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMapMemoryPlacedFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMemoryDecompressionFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMemoryPriorityFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MESH_SHADER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMeshShaderFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MULTI_DRAW_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMultiDrawFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMultiviewFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMutableDescriptorTypeFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceNestedCommandBufferFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceNonSeamlessCubeMapFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceOpacityMicromapFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePerformanceQueryFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PIPELINE_BINARY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineBinaryFeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineCreationCacheControlFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineExecutablePropertiesFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelinePropertiesFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineProtectedAccessFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineRobustnessFeatures));
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePortabilitySubsetFeaturesKHR));
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_ID_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePresentId2FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_ID_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePresentIdFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRESENT_TIMING_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePresentTimingFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePresentWait2FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_WAIT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePresentWaitFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIVATE_DATA_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePrivateDataFeatures));
+        if (gpu.api_version == VK_API_VERSION_1_1 || show_promoted_structs)
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceProtectedMemoryFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceProvokingVertexFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRGBA10X6FormatsFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_QUERY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayQueryFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayTracingInvocationReorderFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayTracingMaintenance1FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayTracingPipelineFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayTracingPositionFetchFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRobustness2FeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSamplerYcbcrConversionFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceScalarBlockLayoutFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSeparateDepthStencilLayoutsFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShader64BitIndexingFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ABORT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderAbortFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderAtomicFloat2FeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderAtomicFloatFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderAtomicInt64Features));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderBfloat16FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_CLOCK_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderClockFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_CONSTANT_DATA_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderConstantDataFeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderDemoteToHelperInvocationFeatures));
+        if (gpu.api_version == VK_API_VERSION_1_1 || show_promoted_structs)
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderDrawParametersFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderExpectAssumeFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderFloat16Int8Features));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_FLOAT8_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderFloat8FeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderFloatControls2Features));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FMA_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderFmaFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderImageAtomicInt64FeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderIntegerDotProductFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderLongVectorFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderModuleIdentifierFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_OBJECT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderObjectFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderQuadControlFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderReplicatedCompositesFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderSubgroupExtendedTypesFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderSubgroupRotateFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderTerminateInvocationFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderTileImageFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderUntypedPointersFeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSubgroupSizeControlFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSubpassMergeFeedbackFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSwapchainMaintenance1FeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSynchronization2Features));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTexelBufferAlignmentFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTextureCompressionASTC3DFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTextureCompressionASTCHDRFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTimelineSemaphoreFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTransformFeedbackFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceUnifiedImageLayoutsFeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceUniformBufferStandardLayoutFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVariablePointersFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME) ||
+             gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVertexAttributeDivisorFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVertexAttributeRobustnessFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVertexInputDynamicStateFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVideoDecodeVP9FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVideoEncodeAV1FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVideoMaintenance1FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVideoMaintenance2FeaturesKHR));
+        if ((gpu.api_version >= VK_API_VERSION_1_2))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan11Features));
+        if ((gpu.api_version >= VK_API_VERSION_1_2))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan12Features));
+        if ((gpu.api_version >= VK_API_VERSION_1_3))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan13Features));
+        if ((gpu.api_version >= VK_API_VERSION_1_4))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan14Features));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkanMemoryModelFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceYcbcrImageArraysFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_phys_device_features2_chain(VkPhysicalDeviceFeatures2 &start, std::unique_ptr<phys_device_features2_chain> &chain,
+                                       AppGpu &gpu, bool show_promoted_structs) {
+    chain = std::unique_ptr<phys_device_features2_chain>(new phys_device_features2_chain());
+    chain->initialize_chain(gpu, show_promoted_structs);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_phys_device_features2(Printer &p, AppGpu &gpu, bool show_promoted_structs, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES) {
+            const VkPhysicalDevice16BitStorageFeatures *props = (const VkPhysicalDevice16BitStorageFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDevice16BitStorageFeatures"
+                                                                     : ("VkPhysicalDevice16BitStorageFeaturesKHR");
+            DumpVkPhysicalDevice16BitStorageFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevice16BitStorageFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_16BIT_STORAGE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevice16BitStorageFeatures(p, "VkPhysicalDevice16BitStorageFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT) {
+            const VkPhysicalDevice4444FormatsFeaturesEXT *props = (const VkPhysicalDevice4444FormatsFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevice4444FormatsFeaturesEXT";
+            DumpVkPhysicalDevice4444FormatsFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES) {
+            const VkPhysicalDevice8BitStorageFeatures *props = (const VkPhysicalDevice8BitStorageFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDevice8BitStorageFeatures"
+                                                                     : ("VkPhysicalDevice8BitStorageFeaturesKHR");
+            DumpVkPhysicalDevice8BitStorageFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevice8BitStorageFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_8BIT_STORAGE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevice8BitStorageFeatures(p, "VkPhysicalDevice8BitStorageFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT) {
+            const VkPhysicalDeviceASTCDecodeFeaturesEXT *props = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceASTCDecodeFeaturesEXT";
+            DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR) {
+            const VkPhysicalDeviceAccelerationStructureFeaturesKHR *props =
+                (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceAccelerationStructureFeaturesKHR";
+            DumpVkPhysicalDeviceAccelerationStructureFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT) {
+            const VkPhysicalDeviceAddressBindingReportFeaturesEXT *props =
+                (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceAddressBindingReportFeaturesEXT";
+            DumpVkPhysicalDeviceAddressBindingReportFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT) {
+            const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *props =
+                (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT";
+            DumpVkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT) {
+            const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *props =
+                (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT";
+            DumpVkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT) {
+            const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *props =
+                (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT";
+            DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT) {
+            const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *props =
+                (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT";
+            DumpVkPhysicalDeviceBorderColorSwizzleFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES) {
+            const VkPhysicalDeviceBufferDeviceAddressFeatures *props =
+                (const VkPhysicalDeviceBufferDeviceAddressFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceBufferDeviceAddressFeatures"
+                                                                     : ("VkPhysicalDeviceBufferDeviceAddressFeaturesKHR");
+            DumpVkPhysicalDeviceBufferDeviceAddressFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceBufferDeviceAddressFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceBufferDeviceAddressFeatures(p, "VkPhysicalDeviceBufferDeviceAddressFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT) {
+            const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *props =
+                (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT"
+                                   : ("VkPhysicalDeviceBufferAddressFeaturesEXT");
+            DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceBufferAddressFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(p, "VkPhysicalDeviceBufferAddressFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT) {
+            const VkPhysicalDeviceColorWriteEnableFeaturesEXT *props =
+                (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceColorWriteEnableFeaturesEXT";
+            DumpVkPhysicalDeviceColorWriteEnableFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR) {
+            const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *props =
+                (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR"
+                                   : ("VkPhysicalDeviceComputeShaderDerivativesFeaturesNV");
+            DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceComputeShaderDerivativesFeaturesNV") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(p, "VkPhysicalDeviceComputeShaderDerivativesFeaturesNV",
+                                                                        *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT) {
+            const VkPhysicalDeviceConditionalRenderingFeaturesEXT *props =
+                (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceConditionalRenderingFeaturesEXT";
+            DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR) {
+            const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *props =
+                (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceCooperativeMatrixFeaturesKHR";
+            DumpVkPhysicalDeviceCooperativeMatrixFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR) {
+            const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *props =
+                (const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR";
+            DumpVkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT) {
+            const VkPhysicalDeviceCustomBorderColorFeaturesEXT *props =
+                (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceCustomBorderColorFeaturesEXT";
+            DumpVkPhysicalDeviceCustomBorderColorFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT) {
+            const VkPhysicalDeviceCustomResolveFeaturesEXT *props = (const VkPhysicalDeviceCustomResolveFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceCustomResolveFeaturesEXT";
+            DumpVkPhysicalDeviceCustomResolveFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT) {
+            const VkPhysicalDeviceDepthBiasControlFeaturesEXT *props =
+                (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDepthBiasControlFeaturesEXT";
+            DumpVkPhysicalDeviceDepthBiasControlFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT) {
+            const VkPhysicalDeviceDepthClampControlFeaturesEXT *props =
+                (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDepthClampControlFeaturesEXT";
+            DumpVkPhysicalDeviceDepthClampControlFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR) {
+            const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *props =
+                (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR"
+                                   : ("VkPhysicalDeviceDepthClampZeroOneFeaturesEXT");
+            DumpVkPhysicalDeviceDepthClampZeroOneFeaturesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDepthClampZeroOneFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDepthClampZeroOneFeaturesKHR(p, "VkPhysicalDeviceDepthClampZeroOneFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT) {
+            const VkPhysicalDeviceDepthClipControlFeaturesEXT *props =
+                (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDepthClipControlFeaturesEXT";
+            DumpVkPhysicalDeviceDepthClipControlFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT) {
+            const VkPhysicalDeviceDepthClipEnableFeaturesEXT *props = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDepthClipEnableFeaturesEXT";
+            DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT) {
+            const VkPhysicalDeviceDescriptorBufferFeaturesEXT *props =
+                (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDescriptorBufferFeaturesEXT";
+            DumpVkPhysicalDeviceDescriptorBufferFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT) {
+            const VkPhysicalDeviceDescriptorHeapFeaturesEXT *props = (const VkPhysicalDeviceDescriptorHeapFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDescriptorHeapFeaturesEXT";
+            DumpVkPhysicalDeviceDescriptorHeapFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES) {
+            const VkPhysicalDeviceDescriptorIndexingFeatures *props = (const VkPhysicalDeviceDescriptorIndexingFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceDescriptorIndexingFeatures"
+                                                                     : ("VkPhysicalDeviceDescriptorIndexingFeaturesEXT");
+            DumpVkPhysicalDeviceDescriptorIndexingFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDescriptorIndexingFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDescriptorIndexingFeatures(p, "VkPhysicalDeviceDescriptorIndexingFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR) {
+            const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR *props =
+                (const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR";
+            DumpVkPhysicalDeviceDeviceAddressCommandsFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT) {
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *props =
+                (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT";
+            DumpVkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT) {
+            const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *props =
+                (const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT";
+            DumpVkPhysicalDeviceDeviceMemoryReportFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES) {
+            const VkPhysicalDeviceDynamicRenderingFeatures *props = (const VkPhysicalDeviceDynamicRenderingFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceDynamicRenderingFeatures"
+                                                                     : ("VkPhysicalDeviceDynamicRenderingFeaturesKHR");
+            DumpVkPhysicalDeviceDynamicRenderingFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDynamicRenderingFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDynamicRenderingFeatures(p, "VkPhysicalDeviceDynamicRenderingFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES) {
+            const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *props =
+                (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceDynamicRenderingLocalReadFeatures"
+                                                                     : ("VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR");
+            DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(p, "VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR",
+                                                                      *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT) {
+            const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *props =
+                (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT";
+            DumpVkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT) {
+            const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *props =
+                (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT";
+            DumpVkPhysicalDeviceExtendedDynamicState2FeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT) {
+            const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *props =
+                (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT";
+            DumpVkPhysicalDeviceExtendedDynamicState3FeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT) {
+            const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *props =
+                (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT";
+            DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT) {
+            const VkPhysicalDeviceFaultFeaturesEXT *props = (const VkPhysicalDeviceFaultFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFaultFeaturesEXT";
+            DumpVkPhysicalDeviceFaultFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR) {
+            const VkPhysicalDeviceFaultFeaturesKHR *props = (const VkPhysicalDeviceFaultFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceFaultFeaturesKHR";
+            DumpVkPhysicalDeviceFaultFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT) {
+            const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *props =
+                (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT";
+            DumpVkPhysicalDeviceFragmentDensityMap2FeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT) {
+            const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *props =
+                (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFragmentDensityMapFeaturesEXT";
+            DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT) {
+            const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *props =
+                (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT"
+                                   : ("VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM");
+            DumpVkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(p, "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM",
+                                                                        *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR) {
+            const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *props =
+                (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR"
+                                   : ("VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV");
+            DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(p, "VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV",
+                                                                         *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT) {
+            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *props =
+                (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT";
+            DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR) {
+            const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *props =
+                (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceFragmentShadingRateFeaturesKHR";
+            DumpVkPhysicalDeviceFragmentShadingRateFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT) {
+            const VkPhysicalDeviceFrameBoundaryFeaturesEXT *props = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFrameBoundaryFeaturesEXT";
+            DumpVkPhysicalDeviceFrameBoundaryFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES) {
+            const VkPhysicalDeviceGlobalPriorityQueryFeatures *props =
+                (const VkPhysicalDeviceGlobalPriorityQueryFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4
+                                   ? "VkPhysicalDeviceGlobalPriorityQueryFeatures"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR"
+                                          : ("VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT"));
+            DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(p, "VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(p, "VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT) {
+            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *props =
+                (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT";
+            DumpVkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES) {
+            const VkPhysicalDeviceHostImageCopyFeatures *props = (const VkPhysicalDeviceHostImageCopyFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceHostImageCopyFeatures"
+                                                                     : ("VkPhysicalDeviceHostImageCopyFeaturesEXT");
+            DumpVkPhysicalDeviceHostImageCopyFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceHostImageCopyFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceHostImageCopyFeatures(p, "VkPhysicalDeviceHostImageCopyFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES) {
+            const VkPhysicalDeviceHostQueryResetFeatures *props = (const VkPhysicalDeviceHostQueryResetFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceHostQueryResetFeatures"
+                                                                     : ("VkPhysicalDeviceHostQueryResetFeaturesEXT");
+            DumpVkPhysicalDeviceHostQueryResetFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceHostQueryResetFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceHostQueryResetFeatures(p, "VkPhysicalDeviceHostQueryResetFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT) {
+            const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *props = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT";
+            DumpVkPhysicalDeviceImage2DViewOf3DFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT) {
+            const VkPhysicalDeviceImageCompressionControlFeaturesEXT *props =
+                (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceImageCompressionControlFeaturesEXT";
+            DumpVkPhysicalDeviceImageCompressionControlFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT) {
+            const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *props =
+                (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT";
+            DumpVkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES) {
+            const VkPhysicalDeviceImageRobustnessFeatures *props = (const VkPhysicalDeviceImageRobustnessFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceImageRobustnessFeatures"
+                                                                     : ("VkPhysicalDeviceImageRobustnessFeaturesEXT");
+            DumpVkPhysicalDeviceImageRobustnessFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceImageRobustnessFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceImageRobustnessFeatures(p, "VkPhysicalDeviceImageRobustnessFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT) {
+            const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *props =
+                (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT";
+            DumpVkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT) {
+            const VkPhysicalDeviceImageViewMinLodFeaturesEXT *props = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceImageViewMinLodFeaturesEXT";
+            DumpVkPhysicalDeviceImageViewMinLodFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES) {
+            const VkPhysicalDeviceImagelessFramebufferFeatures *props =
+                (const VkPhysicalDeviceImagelessFramebufferFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceImagelessFramebufferFeatures"
+                                                                     : ("VkPhysicalDeviceImagelessFramebufferFeaturesKHR");
+            DumpVkPhysicalDeviceImagelessFramebufferFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceImagelessFramebufferFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceImagelessFramebufferFeatures(p, "VkPhysicalDeviceImagelessFramebufferFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES) {
+            const VkPhysicalDeviceIndexTypeUint8Features *props = (const VkPhysicalDeviceIndexTypeUint8Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4
+                                   ? "VkPhysicalDeviceIndexTypeUint8Features"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceIndexTypeUint8FeaturesKHR"
+                                          : ("VkPhysicalDeviceIndexTypeUint8FeaturesEXT"));
+            DumpVkPhysicalDeviceIndexTypeUint8Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceIndexTypeUint8FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceIndexTypeUint8Features(p, "VkPhysicalDeviceIndexTypeUint8FeaturesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceIndexTypeUint8FeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceIndexTypeUint8Features(p, "VkPhysicalDeviceIndexTypeUint8FeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES) {
+            const VkPhysicalDeviceInlineUniformBlockFeatures *props = (const VkPhysicalDeviceInlineUniformBlockFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceInlineUniformBlockFeatures"
+                                                                     : ("VkPhysicalDeviceInlineUniformBlockFeaturesEXT");
+            DumpVkPhysicalDeviceInlineUniformBlockFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceInlineUniformBlockFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceInlineUniformBlockFeatures(p, "VkPhysicalDeviceInlineUniformBlockFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR) {
+            const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *props =
+                (const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR";
+            DumpVkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT) {
+            const VkPhysicalDeviceLegacyDitheringFeaturesEXT *props = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceLegacyDitheringFeaturesEXT";
+            DumpVkPhysicalDeviceLegacyDitheringFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT) {
+            const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *props =
+                (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT";
+            DumpVkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES) {
+            const VkPhysicalDeviceLineRasterizationFeatures *props = (const VkPhysicalDeviceLineRasterizationFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4
+                                   ? "VkPhysicalDeviceLineRasterizationFeatures"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceLineRasterizationFeaturesKHR"
+                                          : ("VkPhysicalDeviceLineRasterizationFeaturesEXT"));
+            DumpVkPhysicalDeviceLineRasterizationFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceLineRasterizationFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceLineRasterizationFeatures(p, "VkPhysicalDeviceLineRasterizationFeaturesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceLineRasterizationFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceLineRasterizationFeatures(p, "VkPhysicalDeviceLineRasterizationFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR) {
+            const VkPhysicalDeviceMaintenance10FeaturesKHR *props = (const VkPhysicalDeviceMaintenance10FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance10FeaturesKHR";
+            DumpVkPhysicalDeviceMaintenance10FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES) {
+            const VkPhysicalDeviceMaintenance4Features *props = (const VkPhysicalDeviceMaintenance4Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceMaintenance4Features"
+                                                                     : ("VkPhysicalDeviceMaintenance4FeaturesKHR");
+            DumpVkPhysicalDeviceMaintenance4Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance4FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance4Features(p, "VkPhysicalDeviceMaintenance4FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES) {
+            const VkPhysicalDeviceMaintenance5Features *props = (const VkPhysicalDeviceMaintenance5Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceMaintenance5Features"
+                                                                     : ("VkPhysicalDeviceMaintenance5FeaturesKHR");
+            DumpVkPhysicalDeviceMaintenance5Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance5FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance5Features(p, "VkPhysicalDeviceMaintenance5FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES) {
+            const VkPhysicalDeviceMaintenance6Features *props = (const VkPhysicalDeviceMaintenance6Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceMaintenance6Features"
+                                                                     : ("VkPhysicalDeviceMaintenance6FeaturesKHR");
+            DumpVkPhysicalDeviceMaintenance6Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance6FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance6Features(p, "VkPhysicalDeviceMaintenance6FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR) {
+            const VkPhysicalDeviceMaintenance7FeaturesKHR *props = (const VkPhysicalDeviceMaintenance7FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance7FeaturesKHR";
+            DumpVkPhysicalDeviceMaintenance7FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR) {
+            const VkPhysicalDeviceMaintenance8FeaturesKHR *props = (const VkPhysicalDeviceMaintenance8FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance8FeaturesKHR";
+            DumpVkPhysicalDeviceMaintenance8FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR) {
+            const VkPhysicalDeviceMaintenance9FeaturesKHR *props = (const VkPhysicalDeviceMaintenance9FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance9FeaturesKHR";
+            DumpVkPhysicalDeviceMaintenance9FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT) {
+            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *props = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT";
+            DumpVkPhysicalDeviceMapMemoryPlacedFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT) {
+            const VkPhysicalDeviceMemoryDecompressionFeaturesEXT *props =
+                (const VkPhysicalDeviceMemoryDecompressionFeaturesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceMemoryDecompressionFeaturesEXT"
+                                   : ("VkPhysicalDeviceMemoryDecompressionFeaturesNV");
+            DumpVkPhysicalDeviceMemoryDecompressionFeaturesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMemoryDecompressionFeaturesNV") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMemoryDecompressionFeaturesEXT(p, "VkPhysicalDeviceMemoryDecompressionFeaturesNV", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT) {
+            const VkPhysicalDeviceMemoryPriorityFeaturesEXT *props = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMemoryPriorityFeaturesEXT";
+            DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT) {
+            const VkPhysicalDeviceMeshShaderFeaturesEXT *props = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMeshShaderFeaturesEXT";
+            DumpVkPhysicalDeviceMeshShaderFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT) {
+            const VkPhysicalDeviceMultiDrawFeaturesEXT *props = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMultiDrawFeaturesEXT";
+            DumpVkPhysicalDeviceMultiDrawFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT) {
+            const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *props =
+                (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT";
+            DumpVkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES) {
+            const VkPhysicalDeviceMultiviewFeatures *props = (const VkPhysicalDeviceMultiviewFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceMultiviewFeatures"
+                                                                     : ("VkPhysicalDeviceMultiviewFeaturesKHR");
+            DumpVkPhysicalDeviceMultiviewFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMultiviewFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMultiviewFeatures(p, "VkPhysicalDeviceMultiviewFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT) {
+            const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *props =
+                (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT"
+                                   : ("VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE");
+            DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(p, "VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE",
+                                                                     *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT) {
+            const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *props =
+                (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceNestedCommandBufferFeaturesEXT";
+            DumpVkPhysicalDeviceNestedCommandBufferFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT) {
+            const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *props =
+                (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT";
+            DumpVkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT) {
+            const VkPhysicalDeviceOpacityMicromapFeaturesEXT *props = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceOpacityMicromapFeaturesEXT";
+            DumpVkPhysicalDeviceOpacityMicromapFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT) {
+            const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *props =
+                (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT";
+            DumpVkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR) {
+            const VkPhysicalDevicePerformanceQueryFeaturesKHR *props =
+                (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePerformanceQueryFeaturesKHR";
+            DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR) {
+            const VkPhysicalDevicePipelineBinaryFeaturesKHR *props = (const VkPhysicalDevicePipelineBinaryFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePipelineBinaryFeaturesKHR";
+            DumpVkPhysicalDevicePipelineBinaryFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES) {
+            const VkPhysicalDevicePipelineCreationCacheControlFeatures *props =
+                (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDevicePipelineCreationCacheControlFeatures"
+                                                                     : ("VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT");
+            DumpVkPhysicalDevicePipelineCreationCacheControlFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePipelineCreationCacheControlFeatures(
+                    p, "VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR) {
+            const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *props =
+                (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR";
+            DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT) {
+            const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *props =
+                (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT";
+            DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT) {
+            const VkPhysicalDevicePipelinePropertiesFeaturesEXT *props =
+                (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevicePipelinePropertiesFeaturesEXT";
+            DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES) {
+            const VkPhysicalDevicePipelineProtectedAccessFeatures *props =
+                (const VkPhysicalDevicePipelineProtectedAccessFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDevicePipelineProtectedAccessFeatures"
+                                                                     : ("VkPhysicalDevicePipelineProtectedAccessFeaturesEXT");
+            DumpVkPhysicalDevicePipelineProtectedAccessFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePipelineProtectedAccessFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePipelineProtectedAccessFeatures(p, "VkPhysicalDevicePipelineProtectedAccessFeaturesEXT",
+                                                                    *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES) {
+            const VkPhysicalDevicePipelineRobustnessFeatures *props = (const VkPhysicalDevicePipelineRobustnessFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDevicePipelineRobustnessFeatures"
+                                                                     : ("VkPhysicalDevicePipelineRobustnessFeaturesEXT");
+            DumpVkPhysicalDevicePipelineRobustnessFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePipelineRobustnessFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePipelineRobustnessFeatures(p, "VkPhysicalDevicePipelineRobustnessFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR && p.Type() != OutputType::json) {
+            const VkPhysicalDevicePortabilitySubsetFeaturesKHR *props =
+                (const VkPhysicalDevicePortabilitySubsetFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePortabilitySubsetFeaturesKHR";
+            DumpVkPhysicalDevicePortabilitySubsetFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR) {
+            const VkPhysicalDevicePresentId2FeaturesKHR *props = (const VkPhysicalDevicePresentId2FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePresentId2FeaturesKHR";
+            DumpVkPhysicalDevicePresentId2FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR) {
+            const VkPhysicalDevicePresentIdFeaturesKHR *props = (const VkPhysicalDevicePresentIdFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePresentIdFeaturesKHR";
+            DumpVkPhysicalDevicePresentIdFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR) {
+            const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *props =
+                (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME)
+                                   ? "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR"
+                                   : ("VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT");
+            DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(
+                    p, "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT) {
+            const VkPhysicalDevicePresentTimingFeaturesEXT *props = (const VkPhysicalDevicePresentTimingFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevicePresentTimingFeaturesEXT";
+            DumpVkPhysicalDevicePresentTimingFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR) {
+            const VkPhysicalDevicePresentWait2FeaturesKHR *props = (const VkPhysicalDevicePresentWait2FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePresentWait2FeaturesKHR";
+            DumpVkPhysicalDevicePresentWait2FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR) {
+            const VkPhysicalDevicePresentWaitFeaturesKHR *props = (const VkPhysicalDevicePresentWaitFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePresentWaitFeaturesKHR";
+            DumpVkPhysicalDevicePresentWaitFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT) {
+            const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *props =
+                (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT";
+            DumpVkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT) {
+            const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *props =
+                (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT";
+            DumpVkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES) {
+            const VkPhysicalDevicePrivateDataFeatures *props = (const VkPhysicalDevicePrivateDataFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDevicePrivateDataFeatures"
+                                                                     : ("VkPhysicalDevicePrivateDataFeaturesEXT");
+            DumpVkPhysicalDevicePrivateDataFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePrivateDataFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIVATE_DATA_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePrivateDataFeatures(p, "VkPhysicalDevicePrivateDataFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES) {
+            const VkPhysicalDeviceProtectedMemoryFeatures *props = (const VkPhysicalDeviceProtectedMemoryFeatures *)structure;
+            const char *name = "VkPhysicalDeviceProtectedMemoryFeatures";
+            DumpVkPhysicalDeviceProtectedMemoryFeatures(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT) {
+            const VkPhysicalDeviceProvokingVertexFeaturesEXT *props = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceProvokingVertexFeaturesEXT";
+            DumpVkPhysicalDeviceProvokingVertexFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT) {
+            const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *props = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT";
+            DumpVkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT) {
+            const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *props =
+                (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT"
+                                   : ("VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM");
+            DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+                    p, "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR) {
+            const VkPhysicalDeviceRayQueryFeaturesKHR *props = (const VkPhysicalDeviceRayQueryFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceRayQueryFeaturesKHR";
+            DumpVkPhysicalDeviceRayQueryFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT) {
+            const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT *props =
+                (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT";
+            DumpVkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR) {
+            const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *props =
+                (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR";
+            DumpVkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR) {
+            const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *props =
+                (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceRayTracingPipelineFeaturesKHR";
+            DumpVkPhysicalDeviceRayTracingPipelineFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR) {
+            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *props =
+                (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR";
+            DumpVkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR) {
+            const VkPhysicalDeviceRobustness2FeaturesKHR *props = (const VkPhysicalDeviceRobustness2FeaturesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceRobustness2FeaturesKHR"
+                                   : ("VkPhysicalDeviceRobustness2FeaturesEXT");
+            DumpVkPhysicalDeviceRobustness2FeaturesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceRobustness2FeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceRobustness2FeaturesKHR(p, "VkPhysicalDeviceRobustness2FeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES) {
+            const VkPhysicalDeviceSamplerYcbcrConversionFeatures *props =
+                (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceSamplerYcbcrConversionFeatures"
+                                                                     : ("VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR");
+            DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(p, "VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES) {
+            const VkPhysicalDeviceScalarBlockLayoutFeatures *props = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceScalarBlockLayoutFeatures"
+                                                                     : ("VkPhysicalDeviceScalarBlockLayoutFeaturesEXT");
+            DumpVkPhysicalDeviceScalarBlockLayoutFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceScalarBlockLayoutFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceScalarBlockLayoutFeatures(p, "VkPhysicalDeviceScalarBlockLayoutFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES) {
+            const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *props =
+                (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures"
+                                                                     : ("VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR");
+            DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(p, "VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR",
+                                                                        *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT) {
+            const VkPhysicalDeviceShader64BitIndexingFeaturesEXT *props =
+                (const VkPhysicalDeviceShader64BitIndexingFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShader64BitIndexingFeaturesEXT";
+            DumpVkPhysicalDeviceShader64BitIndexingFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderAbortFeaturesKHR *props = (const VkPhysicalDeviceShaderAbortFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderAbortFeaturesKHR";
+            DumpVkPhysicalDeviceShaderAbortFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *props =
+                (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT";
+            DumpVkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *props =
+                (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT";
+            DumpVkPhysicalDeviceShaderAtomicFloatFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES) {
+            const VkPhysicalDeviceShaderAtomicInt64Features *props = (const VkPhysicalDeviceShaderAtomicInt64Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceShaderAtomicInt64Features"
+                                                                     : ("VkPhysicalDeviceShaderAtomicInt64FeaturesKHR");
+            DumpVkPhysicalDeviceShaderAtomicInt64Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderAtomicInt64FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderAtomicInt64Features(p, "VkPhysicalDeviceShaderAtomicInt64FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderBfloat16FeaturesKHR *props = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderBfloat16FeaturesKHR";
+            DumpVkPhysicalDeviceShaderBfloat16FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderClockFeaturesKHR *props = (const VkPhysicalDeviceShaderClockFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderClockFeaturesKHR";
+            DumpVkPhysicalDeviceShaderClockFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderConstantDataFeaturesKHR *props =
+                (const VkPhysicalDeviceShaderConstantDataFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderConstantDataFeaturesKHR";
+            DumpVkPhysicalDeviceShaderConstantDataFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES) {
+            const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *props =
+                (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3
+                                   ? "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures"
+                                   : ("VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT");
+            DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+                    p, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES) {
+            const VkPhysicalDeviceShaderDrawParametersFeatures *props =
+                (const VkPhysicalDeviceShaderDrawParametersFeatures *)structure;
+            const char *name = "VkPhysicalDeviceShaderDrawParametersFeatures";
+            DumpVkPhysicalDeviceShaderDrawParametersFeatures(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES) {
+            const VkPhysicalDeviceShaderExpectAssumeFeatures *props = (const VkPhysicalDeviceShaderExpectAssumeFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceShaderExpectAssumeFeatures"
+                                                                     : ("VkPhysicalDeviceShaderExpectAssumeFeaturesKHR");
+            DumpVkPhysicalDeviceShaderExpectAssumeFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderExpectAssumeFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderExpectAssumeFeatures(p, "VkPhysicalDeviceShaderExpectAssumeFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES) {
+            const VkPhysicalDeviceShaderFloat16Int8Features *props = (const VkPhysicalDeviceShaderFloat16Int8Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2
+                                   ? "VkPhysicalDeviceShaderFloat16Int8Features"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceShaderFloat16Int8FeaturesKHR"
+                                          : ("VkPhysicalDeviceFloat16Int8FeaturesKHR"));
+            DumpVkPhysicalDeviceShaderFloat16Int8Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderFloat16Int8FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderFloat16Int8Features(p, "VkPhysicalDeviceShaderFloat16Int8FeaturesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFloat16Int8FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderFloat16Int8Features(p, "VkPhysicalDeviceFloat16Int8FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderFloat8FeaturesEXT *props = (const VkPhysicalDeviceShaderFloat8FeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderFloat8FeaturesEXT";
+            DumpVkPhysicalDeviceShaderFloat8FeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES) {
+            const VkPhysicalDeviceShaderFloatControls2Features *props =
+                (const VkPhysicalDeviceShaderFloatControls2Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceShaderFloatControls2Features"
+                                                                     : ("VkPhysicalDeviceShaderFloatControls2FeaturesKHR");
+            DumpVkPhysicalDeviceShaderFloatControls2Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderFloatControls2FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderFloatControls2Features(p, "VkPhysicalDeviceShaderFloatControls2FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderFmaFeaturesKHR *props = (const VkPhysicalDeviceShaderFmaFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderFmaFeaturesKHR";
+            DumpVkPhysicalDeviceShaderFmaFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *props =
+                (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT";
+            DumpVkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES) {
+            const VkPhysicalDeviceShaderIntegerDotProductFeatures *props =
+                (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceShaderIntegerDotProductFeatures"
+                                                                     : ("VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR");
+            DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(p, "VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR",
+                                                                    *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderLongVectorFeaturesEXT *props =
+                (const VkPhysicalDeviceShaderLongVectorFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderLongVectorFeaturesEXT";
+            DumpVkPhysicalDeviceShaderLongVectorFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *props =
+                (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR";
+            DumpVkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *props =
+                (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT";
+            DumpVkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderObjectFeaturesEXT *props = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderObjectFeaturesEXT";
+            DumpVkPhysicalDeviceShaderObjectFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderQuadControlFeaturesKHR *props =
+                (const VkPhysicalDeviceShaderQuadControlFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderQuadControlFeaturesKHR";
+            DumpVkPhysicalDeviceShaderQuadControlFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *props =
+                (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR";
+            DumpVkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *props =
+                (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT";
+            DumpVkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES) {
+            const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *props =
+                (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures"
+                                                                     : ("VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR");
+            DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(p, "VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR",
+                                                                        *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *props =
+                (const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT";
+            DumpVkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES) {
+            const VkPhysicalDeviceShaderSubgroupRotateFeatures *props =
+                (const VkPhysicalDeviceShaderSubgroupRotateFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceShaderSubgroupRotateFeatures"
+                                                                     : ("VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR");
+            DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(p, "VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *props =
+                (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR";
+            DumpVkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES) {
+            const VkPhysicalDeviceShaderTerminateInvocationFeatures *props =
+                (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceShaderTerminateInvocationFeatures"
+                                                                     : ("VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR");
+            DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(p, "VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR",
+                                                                      *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderTileImageFeaturesEXT *props = (const VkPhysicalDeviceShaderTileImageFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderTileImageFeaturesEXT";
+            DumpVkPhysicalDeviceShaderTileImageFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT *props =
+                (const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT";
+            DumpVkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *props =
+                (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR";
+            DumpVkPhysicalDeviceShaderUntypedPointersFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES) {
+            const VkPhysicalDeviceSubgroupSizeControlFeatures *props =
+                (const VkPhysicalDeviceSubgroupSizeControlFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceSubgroupSizeControlFeatures"
+                                                                     : ("VkPhysicalDeviceSubgroupSizeControlFeaturesEXT");
+            DumpVkPhysicalDeviceSubgroupSizeControlFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSubgroupSizeControlFeatures(p, "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT) {
+            const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *props =
+                (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT";
+            DumpVkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR) {
+            const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *props =
+                (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR"
+                                   : ("VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT");
+            DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(p, "VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES) {
+            const VkPhysicalDeviceSynchronization2Features *props = (const VkPhysicalDeviceSynchronization2Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceSynchronization2Features"
+                                                                     : ("VkPhysicalDeviceSynchronization2FeaturesKHR");
+            DumpVkPhysicalDeviceSynchronization2Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSynchronization2FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSynchronization2Features(p, "VkPhysicalDeviceSynchronization2FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT) {
+            const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *props =
+                (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT";
+            DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT) {
+            const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *props =
+                (const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT";
+            DumpVkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES) {
+            const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *props =
+                (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceTextureCompressionASTCHDRFeatures"
+                                                                     : ("VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT");
+            DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(p, "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT",
+                                                                      *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES) {
+            const VkPhysicalDeviceTimelineSemaphoreFeatures *props = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceTimelineSemaphoreFeatures"
+                                                                     : ("VkPhysicalDeviceTimelineSemaphoreFeaturesKHR");
+            DumpVkPhysicalDeviceTimelineSemaphoreFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceTimelineSemaphoreFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceTimelineSemaphoreFeatures(p, "VkPhysicalDeviceTimelineSemaphoreFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT) {
+            const VkPhysicalDeviceTransformFeedbackFeaturesEXT *props =
+                (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceTransformFeedbackFeaturesEXT";
+            DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR) {
+            const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *props =
+                (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR";
+            DumpVkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES) {
+            const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *props =
+                (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceUniformBufferStandardLayoutFeatures"
+                                                                     : ("VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR");
+            DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(p, "VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR",
+                                                                        *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES) {
+            const VkPhysicalDeviceVariablePointersFeatures *props = (const VkPhysicalDeviceVariablePointersFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1
+                                   ? "VkPhysicalDeviceVariablePointersFeatures"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceVariablePointerFeaturesKHR"
+                                          : ("VkPhysicalDeviceVariablePointersFeaturesKHR"));
+            DumpVkPhysicalDeviceVariablePointersFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVariablePointerFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceVariablePointersFeatures(p, "VkPhysicalDeviceVariablePointerFeaturesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVariablePointersFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceVariablePointersFeatures(p, "VkPhysicalDeviceVariablePointersFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES) {
+            const VkPhysicalDeviceVertexAttributeDivisorFeatures *props =
+                (const VkPhysicalDeviceVertexAttributeDivisorFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4
+                                   ? "VkPhysicalDeviceVertexAttributeDivisorFeatures"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR"
+                                          : ("VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT"));
+            DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(p, "VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(p, "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT) {
+            const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *props =
+                (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT";
+            DumpVkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT) {
+            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *props =
+                (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT";
+            DumpVkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR) {
+            const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *props = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR";
+            DumpVkPhysicalDeviceVideoDecodeVP9FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR) {
+            const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *props = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR";
+            DumpVkPhysicalDeviceVideoEncodeAV1FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR) {
+            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *props =
+                (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR";
+            DumpVkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR) {
+            const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *props =
+                (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR";
+            DumpVkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR) {
+            const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *props =
+                (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceVideoMaintenance1FeaturesKHR";
+            DumpVkPhysicalDeviceVideoMaintenance1FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR) {
+            const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *props =
+                (const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceVideoMaintenance2FeaturesKHR";
+            DumpVkPhysicalDeviceVideoMaintenance2FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES) {
+            const VkPhysicalDeviceVulkan11Features *props = (const VkPhysicalDeviceVulkan11Features *)structure;
+            const char *name = "VkPhysicalDeviceVulkan11Features";
+            DumpVkPhysicalDeviceVulkan11Features(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES) {
+            const VkPhysicalDeviceVulkan12Features *props = (const VkPhysicalDeviceVulkan12Features *)structure;
+            const char *name = "VkPhysicalDeviceVulkan12Features";
+            DumpVkPhysicalDeviceVulkan12Features(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES) {
+            const VkPhysicalDeviceVulkan13Features *props = (const VkPhysicalDeviceVulkan13Features *)structure;
+            const char *name = "VkPhysicalDeviceVulkan13Features";
+            DumpVkPhysicalDeviceVulkan13Features(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES) {
+            const VkPhysicalDeviceVulkan14Features *props = (const VkPhysicalDeviceVulkan14Features *)structure;
+            const char *name = "VkPhysicalDeviceVulkan14Features";
+            DumpVkPhysicalDeviceVulkan14Features(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES) {
+            const VkPhysicalDeviceVulkanMemoryModelFeatures *props = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceVulkanMemoryModelFeatures"
+                                                                     : ("VkPhysicalDeviceVulkanMemoryModelFeaturesKHR");
+            DumpVkPhysicalDeviceVulkanMemoryModelFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVulkanMemoryModelFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceVulkanMemoryModelFeatures(p, "VkPhysicalDeviceVulkanMemoryModelFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR) {
+            const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *props =
+                (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR";
+            DumpVkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT) {
+            const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *props =
+                (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT";
+            DumpVkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT) {
+            const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *props =
+                (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT";
+            DumpVkPhysicalDeviceYcbcrImageArraysFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT) {
+            const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *props =
+                (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT";
+            DumpVkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES) {
+            const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *props =
+                (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures"
+                                                                     : ("VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR");
+            DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+                    p, "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_phys_device_features2_twocall_chain_vectors(std::unique_ptr<phys_device_features2_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct surface_capabilities2_chain {
+    surface_capabilities2_chain() = default;
+    surface_capabilities2_chain(const surface_capabilities2_chain &) = delete;
+    surface_capabilities2_chain &operator=(const surface_capabilities2_chain &) = delete;
+    surface_capabilities2_chain(surface_capabilities2_chain &&) = delete;
+    surface_capabilities2_chain &operator=(surface_capabilities2_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkPresentTimingSurfaceCapabilitiesEXT PresentTimingSurfaceCapabilitiesEXT{};
+    VkSharedPresentSurfaceCapabilitiesKHR SharedPresentSurfaceCapabilitiesKHR{};
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkSurfaceCapabilitiesFullScreenExclusiveEXT SurfaceCapabilitiesFullScreenExclusiveEXT{};
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+    VkSurfaceCapabilitiesPresentId2KHR SurfaceCapabilitiesPresentId2KHR{};
+    VkSurfaceCapabilitiesPresentWait2KHR SurfaceCapabilitiesPresentWait2KHR{};
+    VkSurfaceProtectedCapabilitiesKHR SurfaceProtectedCapabilitiesKHR{};
+    void initialize_chain(AppInstance &inst, AppGpu &gpu) noexcept {
+        PresentTimingSurfaceCapabilitiesEXT.sType = VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT;
+        SharedPresentSurfaceCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        SurfaceCapabilitiesFullScreenExclusiveEXT.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        SurfaceCapabilitiesPresentId2KHR.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR;
+        SurfaceCapabilitiesPresentWait2KHR.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR;
+        SurfaceProtectedCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRESENT_TIMING_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PresentTimingSurfaceCapabilitiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&SharedPresentSurfaceCapabilitiesKHR));
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&SurfaceCapabilitiesFullScreenExclusiveEXT));
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_ID_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&SurfaceCapabilitiesPresentId2KHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&SurfaceCapabilitiesPresentWait2KHR));
+        if (inst.CheckExtensionEnabled(VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&SurfaceProtectedCapabilitiesKHR));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_surface_capabilities2_chain(VkSurfaceCapabilities2KHR &start, std::unique_ptr<surface_capabilities2_chain> &chain,
+                                       AppInstance &inst, AppGpu &gpu) {
+    chain = std::unique_ptr<surface_capabilities2_chain>(new surface_capabilities2_chain());
+    chain->initialize_chain(inst, gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_surface_capabilities2(Printer &p, AppInstance &inst, AppGpu &gpu, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT) {
+            const VkPresentTimingSurfaceCapabilitiesEXT *props = (const VkPresentTimingSurfaceCapabilitiesEXT *)structure;
+            const char *name = "VkPresentTimingSurfaceCapabilitiesEXT";
+            DumpVkPresentTimingSurfaceCapabilitiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR) {
+            const VkSharedPresentSurfaceCapabilitiesKHR *props = (const VkSharedPresentSurfaceCapabilitiesKHR *)structure;
+            const char *name = "VkSharedPresentSurfaceCapabilitiesKHR";
+            DumpVkSharedPresentSurfaceCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT) {
+            const VkSurfaceCapabilitiesFullScreenExclusiveEXT *props =
+                (const VkSurfaceCapabilitiesFullScreenExclusiveEXT *)structure;
+            const char *name = "VkSurfaceCapabilitiesFullScreenExclusiveEXT";
+            DumpVkSurfaceCapabilitiesFullScreenExclusiveEXT(p, name, *props);
+            p.AddNewline();
+        }
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR) {
+            const VkSurfaceCapabilitiesPresentId2KHR *props = (const VkSurfaceCapabilitiesPresentId2KHR *)structure;
+            const char *name = "VkSurfaceCapabilitiesPresentId2KHR";
+            DumpVkSurfaceCapabilitiesPresentId2KHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR) {
+            const VkSurfaceCapabilitiesPresentWait2KHR *props = (const VkSurfaceCapabilitiesPresentWait2KHR *)structure;
+            const char *name = "VkSurfaceCapabilitiesPresentWait2KHR";
+            DumpVkSurfaceCapabilitiesPresentWait2KHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR) {
+            const VkSurfaceProtectedCapabilitiesKHR *props = (const VkSurfaceProtectedCapabilitiesKHR *)structure;
+            const char *name = "VkSurfaceProtectedCapabilitiesKHR";
+            DumpVkSurfaceProtectedCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_surface_capabilities2_twocall_chain_vectors(std::unique_ptr<surface_capabilities2_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct format_properties2_chain {
+    format_properties2_chain() = default;
+    format_properties2_chain(const format_properties2_chain &) = delete;
+    format_properties2_chain &operator=(const format_properties2_chain &) = delete;
+    format_properties2_chain(format_properties2_chain &&) = delete;
+    format_properties2_chain &operator=(format_properties2_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkFormatProperties3 FormatProperties3{};
+    VkSubpassResolvePerformanceQueryEXT SubpassResolvePerformanceQueryEXT{};
+    void initialize_chain(AppGpu &gpu) noexcept {
+        FormatProperties3.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
+        SubpassResolvePerformanceQueryEXT.sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&FormatProperties3));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&SubpassResolvePerformanceQueryEXT));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_format_properties2_chain(VkFormatProperties2 &start, std::unique_ptr<format_properties2_chain> &chain, AppGpu &gpu) {
+    chain = std::unique_ptr<format_properties2_chain>(new format_properties2_chain());
+    chain->initialize_chain(gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_format_properties2(Printer &p, AppGpu &gpu, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3) {
+            const VkFormatProperties3 *props = (const VkFormatProperties3 *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkFormatProperties3" : ("VkFormatProperties3KHR");
+            DumpVkFormatProperties3(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT) {
+            const VkSubpassResolvePerformanceQueryEXT *props = (const VkSubpassResolvePerformanceQueryEXT *)structure;
+            const char *name = "VkSubpassResolvePerformanceQueryEXT";
+            DumpVkSubpassResolvePerformanceQueryEXT(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_format_properties2_twocall_chain_vectors(std::unique_ptr<format_properties2_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct queue_properties2_chain {
+    queue_properties2_chain() = default;
+    queue_properties2_chain(const queue_properties2_chain &) = delete;
+    queue_properties2_chain &operator=(const queue_properties2_chain &) = delete;
+    queue_properties2_chain(queue_properties2_chain &&) = delete;
+    queue_properties2_chain &operator=(queue_properties2_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkQueueFamilyGlobalPriorityProperties QueueFamilyGlobalPriorityProperties{};
+    VkQueueFamilyOwnershipTransferPropertiesKHR QueueFamilyOwnershipTransferPropertiesKHR{};
+    VkQueueFamilyQueryResultStatusPropertiesKHR QueueFamilyQueryResultStatusPropertiesKHR{};
+    VkQueueFamilyVideoPropertiesKHR QueueFamilyVideoPropertiesKHR{};
+    void initialize_chain(AppGpu &gpu) noexcept {
+        QueueFamilyGlobalPriorityProperties.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES;
+        QueueFamilyOwnershipTransferPropertiesKHR.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR;
+        QueueFamilyQueryResultStatusPropertiesKHR.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR;
+        QueueFamilyVideoPropertiesKHR.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME) ||
+             gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&QueueFamilyGlobalPriorityProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_9_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&QueueFamilyOwnershipTransferPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_QUEUE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&QueueFamilyQueryResultStatusPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_QUEUE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&QueueFamilyVideoPropertiesKHR));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_queue_properties2_chain(VkQueueFamilyProperties2 &start, std::unique_ptr<queue_properties2_chain> &chain, AppGpu &gpu) {
+    chain = std::unique_ptr<queue_properties2_chain>(new queue_properties2_chain());
+    chain->initialize_chain(gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_queue_properties2(Printer &p, AppGpu &gpu, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES) {
+            const VkQueueFamilyGlobalPriorityProperties *props = (const VkQueueFamilyGlobalPriorityProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4
+                                   ? "VkQueueFamilyGlobalPriorityProperties"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME)
+                                          ? "VkQueueFamilyGlobalPriorityPropertiesKHR"
+                                          : ("VkQueueFamilyGlobalPriorityPropertiesEXT"));
+            DumpVkQueueFamilyGlobalPriorityProperties(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR) {
+            const VkQueueFamilyOwnershipTransferPropertiesKHR *props =
+                (const VkQueueFamilyOwnershipTransferPropertiesKHR *)structure;
+            const char *name = "VkQueueFamilyOwnershipTransferPropertiesKHR";
+            DumpVkQueueFamilyOwnershipTransferPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR) {
+            const VkQueueFamilyQueryResultStatusPropertiesKHR *props =
+                (const VkQueueFamilyQueryResultStatusPropertiesKHR *)structure;
+            const char *name = "VkQueueFamilyQueryResultStatusPropertiesKHR";
+            DumpVkQueueFamilyQueryResultStatusPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR) {
+            const VkQueueFamilyVideoPropertiesKHR *props = (const VkQueueFamilyVideoPropertiesKHR *)structure;
+            const char *name = "VkQueueFamilyVideoPropertiesKHR";
+            DumpVkQueueFamilyVideoPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_queue_properties2_twocall_chain_vectors(std::unique_ptr<queue_properties2_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct video_profile_info_chain {
+    video_profile_info_chain() = default;
+    video_profile_info_chain(const video_profile_info_chain &) = delete;
+    video_profile_info_chain &operator=(const video_profile_info_chain &) = delete;
+    video_profile_info_chain(video_profile_info_chain &&) = delete;
+    video_profile_info_chain &operator=(video_profile_info_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkVideoDecodeAV1ProfileInfoKHR VideoDecodeAV1ProfileInfoKHR{};
+    VkVideoDecodeH264ProfileInfoKHR VideoDecodeH264ProfileInfoKHR{};
+    VkVideoDecodeH265ProfileInfoKHR VideoDecodeH265ProfileInfoKHR{};
+    VkVideoDecodeUsageInfoKHR VideoDecodeUsageInfoKHR{};
+    VkVideoDecodeVP9ProfileInfoKHR VideoDecodeVP9ProfileInfoKHR{};
+    VkVideoEncodeAV1ProfileInfoKHR VideoEncodeAV1ProfileInfoKHR{};
+    VkVideoEncodeH264ProfileInfoKHR VideoEncodeH264ProfileInfoKHR{};
+    VkVideoEncodeH265ProfileInfoKHR VideoEncodeH265ProfileInfoKHR{};
+    VkVideoEncodeProfileRgbConversionInfoVALVE VideoEncodeProfileRgbConversionInfoVALVE{};
+    VkVideoEncodeUsageInfoKHR VideoEncodeUsageInfoKHR{};
+    void initialize_chain(AppGpu &gpu) noexcept {
+        VideoDecodeAV1ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR;
+        VideoDecodeH264ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR;
+        VideoDecodeH265ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR;
+        VideoDecodeUsageInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR;
+        VideoDecodeVP9ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR;
+        VideoEncodeAV1ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR;
+        VideoEncodeH264ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR;
+        VideoEncodeH265ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR;
+        VideoEncodeProfileRgbConversionInfoVALVE.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE;
+        VideoEncodeUsageInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeAV1ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeH264ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeH265ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeUsageInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeVP9ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeAV1ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeH264ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeH265ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeProfileRgbConversionInfoVALVE));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeUsageInfoKHR));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_video_profile_info_chain(VkVideoProfileInfoKHR &start, std::unique_ptr<video_profile_info_chain> &chain, AppGpu &gpu) {
+    chain = std::unique_ptr<video_profile_info_chain>(new video_profile_info_chain());
+    chain->initialize_chain(gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_video_profile_info(Printer &p, AppGpu &gpu, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR) {
+            const VkVideoDecodeAV1ProfileInfoKHR *props = (const VkVideoDecodeAV1ProfileInfoKHR *)structure;
+            const char *name = "VkVideoDecodeAV1ProfileInfoKHR";
+            DumpVkVideoDecodeAV1ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR) {
+            const VkVideoDecodeH264ProfileInfoKHR *props = (const VkVideoDecodeH264ProfileInfoKHR *)structure;
+            const char *name = "VkVideoDecodeH264ProfileInfoKHR";
+            DumpVkVideoDecodeH264ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR) {
+            const VkVideoDecodeH265ProfileInfoKHR *props = (const VkVideoDecodeH265ProfileInfoKHR *)structure;
+            const char *name = "VkVideoDecodeH265ProfileInfoKHR";
+            DumpVkVideoDecodeH265ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR) {
+            const VkVideoDecodeUsageInfoKHR *props = (const VkVideoDecodeUsageInfoKHR *)structure;
+            const char *name = "VkVideoDecodeUsageInfoKHR";
+            DumpVkVideoDecodeUsageInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR) {
+            const VkVideoDecodeVP9ProfileInfoKHR *props = (const VkVideoDecodeVP9ProfileInfoKHR *)structure;
+            const char *name = "VkVideoDecodeVP9ProfileInfoKHR";
+            DumpVkVideoDecodeVP9ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR) {
+            const VkVideoEncodeAV1ProfileInfoKHR *props = (const VkVideoEncodeAV1ProfileInfoKHR *)structure;
+            const char *name = "VkVideoEncodeAV1ProfileInfoKHR";
+            DumpVkVideoEncodeAV1ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR) {
+            const VkVideoEncodeH264ProfileInfoKHR *props = (const VkVideoEncodeH264ProfileInfoKHR *)structure;
+            const char *name = "VkVideoEncodeH264ProfileInfoKHR";
+            DumpVkVideoEncodeH264ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR) {
+            const VkVideoEncodeH265ProfileInfoKHR *props = (const VkVideoEncodeH265ProfileInfoKHR *)structure;
+            const char *name = "VkVideoEncodeH265ProfileInfoKHR";
+            DumpVkVideoEncodeH265ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE) {
+            const VkVideoEncodeProfileRgbConversionInfoVALVE *props = (const VkVideoEncodeProfileRgbConversionInfoVALVE *)structure;
+            const char *name = "VkVideoEncodeProfileRgbConversionInfoVALVE";
+            DumpVkVideoEncodeProfileRgbConversionInfoVALVE(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR) {
+            const VkVideoEncodeUsageInfoKHR *props = (const VkVideoEncodeUsageInfoKHR *)structure;
+            const char *name = "VkVideoEncodeUsageInfoKHR";
+            DumpVkVideoEncodeUsageInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_video_profile_info_twocall_chain_vectors(std::unique_ptr<video_profile_info_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct video_capabilities_chain {
+    video_capabilities_chain() = default;
+    video_capabilities_chain(const video_capabilities_chain &) = delete;
+    video_capabilities_chain &operator=(const video_capabilities_chain &) = delete;
+    video_capabilities_chain(video_capabilities_chain &&) = delete;
+    video_capabilities_chain &operator=(video_capabilities_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkVideoDecodeAV1CapabilitiesKHR VideoDecodeAV1CapabilitiesKHR{};
+    VkVideoDecodeCapabilitiesKHR VideoDecodeCapabilitiesKHR{};
+    VkVideoDecodeH264CapabilitiesKHR VideoDecodeH264CapabilitiesKHR{};
+    VkVideoDecodeH265CapabilitiesKHR VideoDecodeH265CapabilitiesKHR{};
+    VkVideoDecodeVP9CapabilitiesKHR VideoDecodeVP9CapabilitiesKHR{};
+    VkVideoEncodeAV1CapabilitiesKHR VideoEncodeAV1CapabilitiesKHR{};
+    VkVideoEncodeAV1QuantizationMapCapabilitiesKHR VideoEncodeAV1QuantizationMapCapabilitiesKHR{};
+    VkVideoEncodeCapabilitiesKHR VideoEncodeCapabilitiesKHR{};
+    VkVideoEncodeH264CapabilitiesKHR VideoEncodeH264CapabilitiesKHR{};
+    VkVideoEncodeH264QuantizationMapCapabilitiesKHR VideoEncodeH264QuantizationMapCapabilitiesKHR{};
+    VkVideoEncodeH265CapabilitiesKHR VideoEncodeH265CapabilitiesKHR{};
+    VkVideoEncodeH265QuantizationMapCapabilitiesKHR VideoEncodeH265QuantizationMapCapabilitiesKHR{};
+    VkVideoEncodeIntraRefreshCapabilitiesKHR VideoEncodeIntraRefreshCapabilitiesKHR{};
+    VkVideoEncodeQuantizationMapCapabilitiesKHR VideoEncodeQuantizationMapCapabilitiesKHR{};
+    VkVideoEncodeRgbConversionCapabilitiesVALVE VideoEncodeRgbConversionCapabilitiesVALVE{};
+    void initialize_chain(AppGpu &gpu) noexcept {
+        VideoDecodeAV1CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR;
+        VideoDecodeCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
+        VideoDecodeH264CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR;
+        VideoDecodeH265CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR;
+        VideoDecodeVP9CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR;
+        VideoEncodeAV1CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR;
+        VideoEncodeAV1QuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR;
+        VideoEncodeCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR;
+        VideoEncodeH264CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR;
+        VideoEncodeH264QuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR;
+        VideoEncodeH265CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR;
+        VideoEncodeH265QuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR;
+        VideoEncodeIntraRefreshCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR;
+        VideoEncodeQuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
+        VideoEncodeRgbConversionCapabilitiesVALVE.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeAV1CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeH264CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeH265CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeVP9CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeAV1CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeAV1QuantizationMapCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeH264CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeH264QuantizationMapCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeH265CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeH265QuantizationMapCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeIntraRefreshCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeQuantizationMapCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeRgbConversionCapabilitiesVALVE));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_video_capabilities_chain(VkVideoCapabilitiesKHR &start, std::unique_ptr<video_capabilities_chain> &chain, AppGpu &gpu) {
+    chain = std::unique_ptr<video_capabilities_chain>(new video_capabilities_chain());
+    chain->initialize_chain(gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_video_capabilities(Printer &p, AppGpu &gpu, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR) {
+            const VkVideoDecodeAV1CapabilitiesKHR *props = (const VkVideoDecodeAV1CapabilitiesKHR *)structure;
+            const char *name = "VkVideoDecodeAV1CapabilitiesKHR";
+            DumpVkVideoDecodeAV1CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR) {
+            const VkVideoDecodeCapabilitiesKHR *props = (const VkVideoDecodeCapabilitiesKHR *)structure;
+            const char *name = "VkVideoDecodeCapabilitiesKHR";
+            DumpVkVideoDecodeCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR) {
+            const VkVideoDecodeH264CapabilitiesKHR *props = (const VkVideoDecodeH264CapabilitiesKHR *)structure;
+            const char *name = "VkVideoDecodeH264CapabilitiesKHR";
+            DumpVkVideoDecodeH264CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR) {
+            const VkVideoDecodeH265CapabilitiesKHR *props = (const VkVideoDecodeH265CapabilitiesKHR *)structure;
+            const char *name = "VkVideoDecodeH265CapabilitiesKHR";
+            DumpVkVideoDecodeH265CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR) {
+            const VkVideoDecodeVP9CapabilitiesKHR *props = (const VkVideoDecodeVP9CapabilitiesKHR *)structure;
+            const char *name = "VkVideoDecodeVP9CapabilitiesKHR";
+            DumpVkVideoDecodeVP9CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR) {
+            const VkVideoEncodeAV1CapabilitiesKHR *props = (const VkVideoEncodeAV1CapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeAV1CapabilitiesKHR";
+            DumpVkVideoEncodeAV1CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR) {
+            const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *props =
+                (const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR";
+            DumpVkVideoEncodeAV1QuantizationMapCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR) {
+            const VkVideoEncodeCapabilitiesKHR *props = (const VkVideoEncodeCapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeCapabilitiesKHR";
+            DumpVkVideoEncodeCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR) {
+            const VkVideoEncodeH264CapabilitiesKHR *props = (const VkVideoEncodeH264CapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeH264CapabilitiesKHR";
+            DumpVkVideoEncodeH264CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR) {
+            const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *props =
+                (const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeH264QuantizationMapCapabilitiesKHR";
+            DumpVkVideoEncodeH264QuantizationMapCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR) {
+            const VkVideoEncodeH265CapabilitiesKHR *props = (const VkVideoEncodeH265CapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeH265CapabilitiesKHR";
+            DumpVkVideoEncodeH265CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR) {
+            const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *props =
+                (const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeH265QuantizationMapCapabilitiesKHR";
+            DumpVkVideoEncodeH265QuantizationMapCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR) {
+            const VkVideoEncodeIntraRefreshCapabilitiesKHR *props = (const VkVideoEncodeIntraRefreshCapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeIntraRefreshCapabilitiesKHR";
+            DumpVkVideoEncodeIntraRefreshCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR) {
+            const VkVideoEncodeQuantizationMapCapabilitiesKHR *props =
+                (const VkVideoEncodeQuantizationMapCapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeQuantizationMapCapabilitiesKHR";
+            DumpVkVideoEncodeQuantizationMapCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE) {
+            const VkVideoEncodeRgbConversionCapabilitiesVALVE *props =
+                (const VkVideoEncodeRgbConversionCapabilitiesVALVE *)structure;
+            const char *name = "VkVideoEncodeRgbConversionCapabilitiesVALVE";
+            DumpVkVideoEncodeRgbConversionCapabilitiesVALVE(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_video_capabilities_twocall_chain_vectors(std::unique_ptr<video_capabilities_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct video_format_properties_chain {
+    video_format_properties_chain() = default;
+    video_format_properties_chain(const video_format_properties_chain &) = delete;
+    video_format_properties_chain &operator=(const video_format_properties_chain &) = delete;
+    video_format_properties_chain(video_format_properties_chain &&) = delete;
+    video_format_properties_chain &operator=(video_format_properties_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkVideoFormatAV1QuantizationMapPropertiesKHR VideoFormatAV1QuantizationMapPropertiesKHR{};
+    VkVideoFormatH265QuantizationMapPropertiesKHR VideoFormatH265QuantizationMapPropertiesKHR{};
+    VkVideoFormatQuantizationMapPropertiesKHR VideoFormatQuantizationMapPropertiesKHR{};
+    void initialize_chain(AppGpu &gpu) noexcept {
+        VideoFormatAV1QuantizationMapPropertiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR;
+        VideoFormatH265QuantizationMapPropertiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR;
+        VideoFormatQuantizationMapPropertiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoFormatAV1QuantizationMapPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoFormatH265QuantizationMapPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoFormatQuantizationMapPropertiesKHR));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_video_format_properties_chain(VkVideoFormatPropertiesKHR &start, std::unique_ptr<video_format_properties_chain> &chain,
+                                         AppGpu &gpu) {
+    chain = std::unique_ptr<video_format_properties_chain>(new video_format_properties_chain());
+    chain->initialize_chain(gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_video_format_properties(Printer &p, AppGpu &gpu, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR) {
+            const VkVideoFormatAV1QuantizationMapPropertiesKHR *props =
+                (const VkVideoFormatAV1QuantizationMapPropertiesKHR *)structure;
+            const char *name = "VkVideoFormatAV1QuantizationMapPropertiesKHR";
+            DumpVkVideoFormatAV1QuantizationMapPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR) {
+            const VkVideoFormatH265QuantizationMapPropertiesKHR *props =
+                (const VkVideoFormatH265QuantizationMapPropertiesKHR *)structure;
+            const char *name = "VkVideoFormatH265QuantizationMapPropertiesKHR";
+            DumpVkVideoFormatH265QuantizationMapPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR) {
+            const VkVideoFormatQuantizationMapPropertiesKHR *props = (const VkVideoFormatQuantizationMapPropertiesKHR *)structure;
+            const char *name = "VkVideoFormatQuantizationMapPropertiesKHR";
+            DumpVkVideoFormatQuantizationMapPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_video_format_properties_twocall_chain_vectors(std::unique_ptr<video_format_properties_chain> &chain) {
+    (void)chain;
+    return false;
+}
+bool operator==(const VkExtent2D &a, const VkExtent2D b);
+bool operator==(const VkSurfaceCapabilities2EXT &a, const VkSurfaceCapabilities2EXT b);
+bool operator==(const VkSurfaceCapabilities2KHR &a, const VkSurfaceCapabilities2KHR b);
+bool operator==(const VkSurfaceCapabilitiesKHR &a, const VkSurfaceCapabilitiesKHR b);
+bool operator==(const VkSurfaceFormat2KHR &a, const VkSurfaceFormat2KHR b);
+bool operator==(const VkSurfaceFormatKHR &a, const VkSurfaceFormatKHR b);
+bool operator==(const VkExtent2D &a, const VkExtent2D b) { return a.width == b.width && a.height == b.height; }
+bool operator==(const VkSurfaceCapabilities2EXT &a, const VkSurfaceCapabilities2EXT b) {
+    return a.minImageCount == b.minImageCount && a.maxImageCount == b.maxImageCount && a.currentExtent == b.currentExtent &&
+           a.minImageExtent == b.minImageExtent && a.maxImageExtent == b.maxImageExtent &&
+           a.maxImageArrayLayers == b.maxImageArrayLayers && a.supportedTransforms == b.supportedTransforms &&
+           a.currentTransform == b.currentTransform && a.supportedCompositeAlpha == b.supportedCompositeAlpha &&
+           a.supportedUsageFlags == b.supportedUsageFlags && a.supportedSurfaceCounters == b.supportedSurfaceCounters;
+}
+bool operator==(const VkSurfaceCapabilities2KHR &a, const VkSurfaceCapabilities2KHR b) {
+    return a.surfaceCapabilities == b.surfaceCapabilities;
+}
+bool operator==(const VkSurfaceCapabilitiesKHR &a, const VkSurfaceCapabilitiesKHR b) {
+    return a.minImageCount == b.minImageCount && a.maxImageCount == b.maxImageCount && a.currentExtent == b.currentExtent &&
+           a.minImageExtent == b.minImageExtent && a.maxImageExtent == b.maxImageExtent &&
+           a.maxImageArrayLayers == b.maxImageArrayLayers && a.supportedTransforms == b.supportedTransforms &&
+           a.currentTransform == b.currentTransform && a.supportedCompositeAlpha == b.supportedCompositeAlpha &&
+           a.supportedUsageFlags == b.supportedUsageFlags;
+}
+bool operator==(const VkSurfaceFormat2KHR &a, const VkSurfaceFormat2KHR b) { return a.surfaceFormat == b.surfaceFormat; }
+bool operator==(const VkSurfaceFormatKHR &a, const VkSurfaceFormatKHR b) {
+    return a.format == b.format && a.colorSpace == b.colorSpace;
+}
+std::ostream &operator<<(std::ostream &o, VkExtent2D &obj) { return o << "(" << obj.width << ',' << obj.height << ")"; }
+std::ostream &operator<<(std::ostream &o, VkExtent3D &obj) {
+    return o << "(" << obj.width << ',' << obj.height << ',' << obj.depth << ")";
+}
+auto format_ranges = std::array{
+    FormatRange{0, nullptr, static_cast<VkFormat>(0), static_cast<VkFormat>(184)},
+    FormatRange{VK_API_VERSION_1_1, nullptr, static_cast<VkFormat>(1000156000), static_cast<VkFormat>(1000156033)},
+    FormatRange{0, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, static_cast<VkFormat>(1000156000),
+                static_cast<VkFormat>(1000156033)},
+    FormatRange{VK_API_VERSION_1_3, nullptr, static_cast<VkFormat>(1000330000), static_cast<VkFormat>(1000330003)},
+    FormatRange{0, VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME, static_cast<VkFormat>(1000330000),
+                static_cast<VkFormat>(1000330003)},
+    FormatRange{VK_API_VERSION_1_3, nullptr, static_cast<VkFormat>(1000340000), static_cast<VkFormat>(1000340001)},
+    FormatRange{0, VK_EXT_4444_FORMATS_EXTENSION_NAME, static_cast<VkFormat>(1000340000), static_cast<VkFormat>(1000340001)},
+    FormatRange{VK_API_VERSION_1_3, nullptr, static_cast<VkFormat>(1000066000), static_cast<VkFormat>(1000066013)},
+    FormatRange{0, VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME, static_cast<VkFormat>(1000066000),
+                static_cast<VkFormat>(1000066013)},
+    FormatRange{VK_API_VERSION_1_4, nullptr, static_cast<VkFormat>(1000470000), static_cast<VkFormat>(1000470001)},
+    FormatRange{0, VK_KHR_MAINTENANCE_5_EXTENSION_NAME, static_cast<VkFormat>(1000470000), static_cast<VkFormat>(1000470001)},
+    FormatRange{0, VK_IMG_FORMAT_PVRTC_EXTENSION_NAME, static_cast<VkFormat>(1000054000), static_cast<VkFormat>(1000054007)},
+    FormatRange{0, VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME, static_cast<VkFormat>(1000288000),
+                static_cast<VkFormat>(1000288029)},
+    FormatRange{0, VK_ARM_TENSORS_EXTENSION_NAME, static_cast<VkFormat>(1000460000), static_cast<VkFormat>(1000460003)},
+    FormatRange{0, VK_NV_OPTICAL_FLOW_EXTENSION_NAME, static_cast<VkFormat>(1000464000), static_cast<VkFormat>(1000464000)},
+    FormatRange{0, VK_ARM_FORMAT_PACK_EXTENSION_NAME, static_cast<VkFormat>(1000609000), static_cast<VkFormat>(1000609013)},
+};
+
+bool is_video_format_same(const VkVideoFormatPropertiesKHR &format_a, const VkVideoFormatPropertiesKHR &format_b) {
+    auto a = reinterpret_cast<const VkBaseInStructure *>(&format_a);
+    auto b = reinterpret_cast<const VkBaseInStructure *>(&format_b);
+    bool same = true;
+    while (same && a != nullptr && b != nullptr) {
+        if (a->sType != b->sType) {
+            // Structure type mismatch (extension structures are expected to be chained in the same order)
+            same = false;
+        } else {
+            switch (a->sType) {
+                case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR:
+                    same = same && memcmp(reinterpret_cast<const char *>(a) + sizeof(VkBaseInStructure),
+                                          reinterpret_cast<const char *>(b) + sizeof(VkBaseInStructure),
+                                          sizeof(VkVideoFormatPropertiesKHR) - sizeof(VkBaseInStructure)) == 0;
+                    break;
+                case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
+                    same = same && memcmp(reinterpret_cast<const char *>(a) + sizeof(VkBaseInStructure),
+                                          reinterpret_cast<const char *>(b) + sizeof(VkBaseInStructure),
+                                          sizeof(VkVideoFormatAV1QuantizationMapPropertiesKHR) - sizeof(VkBaseInStructure)) == 0;
+                    break;
+                case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
+                    same = same && memcmp(reinterpret_cast<const char *>(a) + sizeof(VkBaseInStructure),
+                                          reinterpret_cast<const char *>(b) + sizeof(VkBaseInStructure),
+                                          sizeof(VkVideoFormatH265QuantizationMapPropertiesKHR) - sizeof(VkBaseInStructure)) == 0;
+                    break;
+                case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
+                    same = same && memcmp(reinterpret_cast<const char *>(a) + sizeof(VkBaseInStructure),
+                                          reinterpret_cast<const char *>(b) + sizeof(VkBaseInStructure),
+                                          sizeof(VkVideoFormatQuantizationMapPropertiesKHR) - sizeof(VkBaseInStructure)) == 0;
+                    break;
+                default:
+                    // Unexpected structure type
+                    same = false;
+                    break;
+            }
+        }
+        a = a->pNext;
+        b = b->pNext;
+    }
+    return same;
+}
+
+std::vector<std::unique_ptr<AppVideoProfile>> enumerate_supported_video_profiles(AppGpu &gpu) {
+    std::vector<std::unique_ptr<AppVideoProfile>> result{};
+
+    struct ChromaSubsamplingInfo {
+        VkVideoChromaSubsamplingFlagsKHR value;
+        const char *name;
+    };
+    const std::vector<ChromaSubsamplingInfo> chroma_subsampling_list = {
+        {VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, "4:2:0"},
+        {VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR, "4:2:2"},
+        {VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR, "4:4:4"},
+        {VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR, "monochrome"}};
+
+    struct BitDepthInfo {
+        VkVideoComponentBitDepthFlagsKHR value;
+        const char *name;
+    };
+    const std::vector<BitDepthInfo> bit_depth_list = {{VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, "8"},
+                                                      {VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR, "10"},
+                                                      {VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR, "12"}};
+
+    auto find_caps_struct = [](const VkVideoCapabilitiesKHR &capabilities, VkStructureType stype) -> const VkBaseInStructure * {
+        auto p = reinterpret_cast<const VkBaseInStructure *>(&capabilities);
+        while (p != nullptr) {
+            if (p->sType == stype) {
+                return p;
+            }
+            p = p->pNext;
+        }
+        return nullptr;
+    };
+
+    auto base_format = [](const ChromaSubsamplingInfo &chroma_subsampling, const BitDepthInfo &luma_bit_depth,
+                          const BitDepthInfo &chroma_bit_depth) {
+        std::string result{};
+        result += " (";
+        result += chroma_subsampling.name;
+        result += " ";
+        result += luma_bit_depth.name;
+        if (luma_bit_depth.value != chroma_bit_depth.value) {
+            result += ":";
+            result += chroma_bit_depth.name;
+        }
+        result += "-bit)";
+        return result;
+    };
+
+    auto add_profile = [&](const std::string &name, const VkVideoProfileInfoKHR &profile_info,
+                           AppVideoProfile::CreateProfileInfoChainCb create_profile_info_chain,
+                           AppVideoProfile::CreateCapabilitiesChainCb create_capabilities_chain,
+                           const AppVideoProfile::CreateFormatPropertiesChainCbList &create_format_properties_chain_list,
+                           AppVideoProfile::InitProfileCb init_profile) {
+        auto profile =
+            std::make_unique<AppVideoProfile>(gpu, gpu.phys_device, name, profile_info, create_profile_info_chain,
+                                              create_capabilities_chain, create_format_properties_chain_list, init_profile);
+        if (profile->supported) {
+            result.push_back(std::move(profile));
+        }
+    };
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME)) {
+        const std::string codec_name = "H.264 Decode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoDecodeH264ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoDecodeH264ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoDecodeH264ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoDecodeH264ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeH264CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeH264CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeH264CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeH264CapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Decode Output",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Baseline progressive", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_BASELINE;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR;
+                                });
+                    add_profile(profile_base_name + " Main progressive", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_MAIN;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR;
+                                });
+                    add_profile(profile_base_name + " High progressive", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR;
+                                });
+                    add_profile(profile_base_name + " High 4:4:4 Predictive progressive", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR;
+                                });
+                    add_profile(profile_base_name + " Baseline interlaced (interleaved lines)", profile_info,
+                                create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list,
+                                [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_BASELINE;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " Main interlaced (interleaved lines)", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_MAIN;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " High interlaced (interleaved lines)", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " High 4:4:4 Predictive interlaced (interleaved lines)", profile_info,
+                                create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list,
+                                [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " Baseline interlaced (separate planes)", profile_info,
+                                create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list,
+                                [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_BASELINE;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " Main interlaced (separate planes)", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_MAIN;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " High interlaced (separate planes)", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " High 4:4:4 Predictive interlaced (separate planes)", profile_info,
+                                create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list,
+                                [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR;
+                                });
+                }
+            }
+        }
+    }
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME)) {
+        const std::string codec_name = "H.265 Decode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoDecodeH265ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoDecodeH265ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoDecodeH265ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoDecodeH265ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeH265CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeH265CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeH265CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeH265CapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Decode Output",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Main", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_MAIN;
+                                });
+                    add_profile(profile_base_name + " Main 10", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_MAIN_10;
+                                });
+                    add_profile(profile_base_name + " Main Still Picture", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE;
+                                });
+                    add_profile(profile_base_name + " Format range extensions", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS;
+                                });
+                    add_profile(profile_base_name + " Screen content coding extensions", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS;
+                                });
+                }
+            }
+        }
+    }
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME)) {
+        const std::string codec_name = "VP9 Decode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoDecodeVP9ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoDecodeVP9ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoDecodeVP9ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoDecodeVP9ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeVP9CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeVP9CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeVP9CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeVP9CapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Decode Output",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Profile 0", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_0;
+                                });
+                    add_profile(profile_base_name + " Profile 1", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_1;
+                                });
+                    add_profile(profile_base_name + " Profile 2", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_2;
+                                });
+                    add_profile(profile_base_name + " Profile 3", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_3;
+                                });
+                }
+            }
+        }
+    }
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME)) {
+        const std::string codec_name = "AV1 Decode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoDecodeAV1ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoDecodeAV1ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoDecodeAV1ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoDecodeAV1ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeAV1CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeAV1CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeAV1CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeAV1CapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Decode Output",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Main with film grain support", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_MAIN;
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_TRUE;
+                                });
+                    add_profile(profile_base_name + " High with film grain support", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_HIGH;
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_TRUE;
+                                });
+                    add_profile(profile_base_name + " Professional with film grain support", profile_info,
+                                create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list,
+                                [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_PROFESSIONAL;
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_TRUE;
+                                });
+                    add_profile(profile_base_name + " Main without film grain support", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_MAIN;
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_FALSE;
+                                });
+                    add_profile(profile_base_name + " High without film grain support", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_HIGH;
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_FALSE;
+                                });
+                    add_profile(profile_base_name + " Professional without film grain support", profile_info,
+                                create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list,
+                                [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_PROFESSIONAL;
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_FALSE;
+                                });
+                }
+            }
+        }
+    }
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME)) {
+        const std::string codec_name = "H.264 Encode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoEncodeH264ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoEncodeH264ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoEncodeH264ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoEncodeH264ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE;
+                                capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE;
+                                ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeH264CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeH264CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeH264CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeH264CapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeH264QuantizationMapCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeH264QuantizationMapCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeH264QuantizationMapCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeH264QuantizationMapCapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Encode Input",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Quantization Delta Map",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                    auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(
+                                        find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR));
+                                    if (caps != nullptr) {
+                                        supported =
+                                            supported &&
+                                            ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR) != 0);
+                                    } else {
+                                        supported = false;
+                                    }
+                                } else {
+                                    supported = false;
+                                }
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Emphasis Map",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                    auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(
+                                        find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR));
+                                    if (caps != nullptr) {
+                                        supported =
+                                            supported && ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR) != 0);
+                                    } else {
+                                        supported = false;
+                                    }
+                                } else {
+                                    supported = false;
+                                }
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Baseline", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_BASELINE;
+                                });
+                    add_profile(profile_base_name + " Main", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_MAIN;
+                                });
+                    add_profile(profile_base_name + " High", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH;
+                                });
+                    add_profile(profile_base_name + " High 4:4:4 Predictive", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE;
+                                });
+                }
+            }
+        }
+    }
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME)) {
+        const std::string codec_name = "H.265 Encode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoEncodeH265ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoEncodeH265ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoEncodeH265ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoEncodeH265ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE;
+                                capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE;
+                                ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeH265CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeH265CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeH265CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeH265CapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeH265QuantizationMapCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeH265QuantizationMapCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeH265QuantizationMapCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeH265QuantizationMapCapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Encode Input",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Quantization Delta Map",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                    auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(
+                                        find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR));
+                                    if (caps != nullptr) {
+                                        supported =
+                                            supported &&
+                                            ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR) != 0);
+                                    } else {
+                                        supported = false;
+                                    }
+                                } else {
+                                    supported = false;
+                                }
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Emphasis Map",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                    auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(
+                                        find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR));
+                                    if (caps != nullptr) {
+                                        supported =
+                                            supported && ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR) != 0);
+                                    } else {
+                                        supported = false;
+                                    }
+                                } else {
+                                    supported = false;
+                                }
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Main", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_MAIN;
+                                });
+                    add_profile(profile_base_name + " Main 10", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_MAIN_10;
+                                });
+                    add_profile(profile_base_name + " Main Still Picture", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE;
+                                });
+                    add_profile(profile_base_name + " Format range extensions", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS;
+                                });
+                    add_profile(profile_base_name + " Screen content coding extensions", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS;
+                                });
+                }
+            }
+        }
+    }
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME)) {
+        const std::string codec_name = "AV1 Encode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoEncodeAV1ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoEncodeAV1ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoEncodeAV1ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoEncodeAV1ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE;
+                                capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE;
+                                ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeAV1CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeAV1CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeAV1CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeAV1CapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Encode Input",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Quantization Delta Map",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                    auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(
+                                        find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR));
+                                    if (caps != nullptr) {
+                                        supported =
+                                            supported &&
+                                            ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR) != 0);
+                                    } else {
+                                        supported = false;
+                                    }
+                                } else {
+                                    supported = false;
+                                }
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Emphasis Map",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                    auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(
+                                        find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR));
+                                    if (caps != nullptr) {
+                                        supported =
+                                            supported && ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR) != 0);
+                                    } else {
+                                        supported = false;
+                                    }
+                                } else {
+                                    supported = false;
+                                }
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Main", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_MAIN;
+                                });
+                    add_profile(profile_base_name + " High", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_HIGH;
+                                });
+                    add_profile(profile_base_name + " Professional", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_PROFESSIONAL;
+                                });
+                }
+            }
+        }
+    }
+    return result;
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.pbxproj b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.pbxproj
new file mode 100644
index 00000000..41ab580a
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.pbxproj
@@ -0,0 +1,411 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 52;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		A06CCB40258D04F700B0A7DA /* vulkaninfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A06CCB3F258D04F700B0A7DA /* vulkaninfo.cpp */; };
+		A06CCB44258D0BE300B0A7DA /* MoltenVK.xcframework in Frameworks */ = {isa = PBXBuildFile; fileRef = A06CCB43258D0BE300B0A7DA /* MoltenVK.xcframework */; };
+		A07BD431255B45E000B79448 /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = A07BD430255B45E000B79448 /* AppDelegate.m */; };
+		A07BD434255B45E000B79448 /* SceneDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = A07BD433255B45E000B79448 /* SceneDelegate.m */; };
+		A07BD437255B45E000B79448 /* ViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = A07BD436255B45E000B79448 /* ViewController.m */; };
+		A07BD43A255B45E100B79448 /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = A07BD438255B45E100B79448 /* Main.storyboard */; };
+		A07BD43C255B45E200B79448 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = A07BD43B255B45E200B79448 /* Assets.xcassets */; };
+		A07BD43F255B45E200B79448 /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = A07BD43D255B45E200B79448 /* LaunchScreen.storyboard */; };
+		A07BD442255B45E200B79448 /* main.mm in Sources */ = {isa = PBXBuildFile; fileRef = A07BD441255B45E200B79448 /* main.mm */; };
+		A07BD48D255B4DEE00B79448 /* metal_iosview.m in Sources */ = {isa = PBXBuildFile; fileRef = A07BD48C255B4DEE00B79448 /* metal_iosview.m */; };
+		A07BD4A5255C914A00B79448 /* WebKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A07BD4A4255C914A00B79448 /* WebKit.framework */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		A06CCB3F258D04F700B0A7DA /* vulkaninfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = vulkaninfo.cpp; path = ../vulkaninfo.cpp; sourceTree = "<group>"; };
+		A06CCB43258D0BE300B0A7DA /* MoltenVK.xcframework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcframework; name = MoltenVK.xcframework; path = ../../../../VulkanSDK/MoltenVK/MoltenVK.xcframework; sourceTree = "<group>"; };
+		A07BD42C255B45E000B79448 /* vulkaninfo.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = vulkaninfo.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		A07BD42F255B45E000B79448 /* AppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = "<group>"; };
+		A07BD430255B45E000B79448 /* AppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = AppDelegate.m; sourceTree = "<group>"; };
+		A07BD432255B45E000B79448 /* SceneDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SceneDelegate.h; sourceTree = "<group>"; };
+		A07BD433255B45E000B79448 /* SceneDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SceneDelegate.m; sourceTree = "<group>"; };
+		A07BD435255B45E000B79448 /* ViewController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ViewController.h; sourceTree = "<group>"; };
+		A07BD436255B45E000B79448 /* ViewController.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = ViewController.m; sourceTree = "<group>"; };
+		A07BD439255B45E100B79448 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = "<group>"; };
+		A07BD43B255B45E200B79448 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		A07BD43E255B45E200B79448 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
+		A07BD440255B45E200B79448 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		A07BD441255B45E200B79448 /* main.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = main.mm; sourceTree = "<group>"; };
+		A07BD48C255B4DEE00B79448 /* metal_iosview.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = metal_iosview.m; sourceTree = "<group>"; };
+		A07BD48F255B4DF900B79448 /* metal_iosview.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = metal_iosview.h; sourceTree = "<group>"; };
+		A07BD4A4255C914A00B79448 /* WebKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = WebKit.framework; path = System/Library/Frameworks/WebKit.framework; sourceTree = SDKROOT; };
+		A0F9358C2575C05A00CFA527 /* vulkaninfo.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = vulkaninfo.entitlements; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		A07BD429255B45E000B79448 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				A06CCB44258D0BE300B0A7DA /* MoltenVK.xcframework in Frameworks */,
+				A07BD4A5255C914A00B79448 /* WebKit.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		A06CCB3E258D04E200B0A7DA /* Shared */ = {
+			isa = PBXGroup;
+			children = (
+				A06CCB3F258D04F700B0A7DA /* vulkaninfo.cpp */,
+			);
+			name = Shared;
+			sourceTree = "<group>";
+		};
+		A07BD423255B45E000B79448 = {
+			isa = PBXGroup;
+			children = (
+				A06CCB3E258D04E200B0A7DA /* Shared */,
+				A07BD473255B48AB00B79448 /* Frameworks */,
+				A07BD42E255B45E000B79448 /* vulkaninfo */,
+				A07BD42D255B45E000B79448 /* Products */,
+			);
+			sourceTree = "<group>";
+		};
+		A07BD42D255B45E000B79448 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				A07BD42C255B45E000B79448 /* vulkaninfo.app */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		A07BD42E255B45E000B79448 /* vulkaninfo */ = {
+			isa = PBXGroup;
+			children = (
+				A0F9358C2575C05A00CFA527 /* vulkaninfo.entitlements */,
+				A07BD48F255B4DF900B79448 /* metal_iosview.h */,
+				A07BD48C255B4DEE00B79448 /* metal_iosview.m */,
+				A07BD42F255B45E000B79448 /* AppDelegate.h */,
+				A07BD430255B45E000B79448 /* AppDelegate.m */,
+				A07BD432255B45E000B79448 /* SceneDelegate.h */,
+				A07BD433255B45E000B79448 /* SceneDelegate.m */,
+				A07BD435255B45E000B79448 /* ViewController.h */,
+				A07BD436255B45E000B79448 /* ViewController.m */,
+				A07BD438255B45E100B79448 /* Main.storyboard */,
+				A07BD43B255B45E200B79448 /* Assets.xcassets */,
+				A07BD43D255B45E200B79448 /* LaunchScreen.storyboard */,
+				A07BD440255B45E200B79448 /* Info.plist */,
+				A07BD441255B45E200B79448 /* main.mm */,
+			);
+			path = vulkaninfo;
+			sourceTree = "<group>";
+		};
+		A07BD473255B48AB00B79448 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				A06CCB43258D0BE300B0A7DA /* MoltenVK.xcframework */,
+				A07BD4A4255C914A00B79448 /* WebKit.framework */,
+			);
+			path = Frameworks;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		A07BD42B255B45E000B79448 /* vulkaninfo */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = A07BD445255B45E200B79448 /* Build configuration list for PBXNativeTarget "vulkaninfo" */;
+			buildPhases = (
+				A07BD428255B45E000B79448 /* Sources */,
+				A07BD429255B45E000B79448 /* Frameworks */,
+				A07BD42A255B45E000B79448 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = vulkaninfo;
+			productName = vulkaninfo;
+			productReference = A07BD42C255B45E000B79448 /* vulkaninfo.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		A07BD424255B45E000B79448 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 1210;
+				TargetAttributes = {
+					A07BD42B255B45E000B79448 = {
+						CreatedOnToolsVersion = 12.1;
+					};
+				};
+			};
+			buildConfigurationList = A07BD427255B45E000B79448 /* Build configuration list for PBXProject "vulkaninfo" */;
+			compatibilityVersion = "Xcode 9.3";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = A07BD423255B45E000B79448;
+			productRefGroup = A07BD42D255B45E000B79448 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				A07BD42B255B45E000B79448 /* vulkaninfo */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		A07BD42A255B45E000B79448 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				A07BD43F255B45E200B79448 /* LaunchScreen.storyboard in Resources */,
+				A07BD43C255B45E200B79448 /* Assets.xcassets in Resources */,
+				A07BD43A255B45E100B79448 /* Main.storyboard in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		A07BD428255B45E000B79448 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				A07BD437255B45E000B79448 /* ViewController.m in Sources */,
+				A07BD431255B45E000B79448 /* AppDelegate.m in Sources */,
+				A06CCB40258D04F700B0A7DA /* vulkaninfo.cpp in Sources */,
+				A07BD442255B45E200B79448 /* main.mm in Sources */,
+				A07BD48D255B4DEE00B79448 /* metal_iosview.m in Sources */,
+				A07BD434255B45E000B79448 /* SceneDelegate.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXVariantGroup section */
+		A07BD438255B45E100B79448 /* Main.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				A07BD439255B45E100B79448 /* Base */,
+			);
+			name = Main.storyboard;
+			sourceTree = "<group>";
+		};
+		A07BD43D255B45E200B79448 /* LaunchScreen.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				A07BD43E255B45E200B79448 /* Base */,
+			);
+			name = LaunchScreen.storyboard;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		A07BD443255B45E200B79448 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 14.1;
+				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
+				MTL_FAST_MATH = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+			};
+			name = Debug;
+		};
+		A07BD444255B45E200B79448 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 14.1;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				MTL_FAST_MATH = YES;
+				SDKROOT = iphoneos;
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		A07BD446255B45E200B79448 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
+				CODE_SIGN_ENTITLEMENTS = vulkaninfo/vulkaninfo.entitlements;
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 5;
+				DEVELOPMENT_TEAM = 4777T3625D;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					VK_USE_PLATFORM_IOS_MVK,
+					VK_ENABLE_BETA_EXTENSIONS,
+				);
+				HEADER_SEARCH_PATHS = (
+					"\"$(SRCROOT)/../../build/Vulkan-Headers/include\"",
+					"\"$(SRCROOT)/../generated\"",
+					"\"$(SRCROOT)/..\"",
+					"\"$(SRCROOT)/vulkaninfo\"",
+				);
+				INFOPLIST_FILE = vulkaninfo/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.lunarg.vulkaninfo;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SUPPORTS_MACCATALYST = YES;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		A07BD447255B45E200B79448 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
+				CODE_SIGN_ENTITLEMENTS = vulkaninfo/vulkaninfo.entitlements;
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 5;
+				DEVELOPMENT_TEAM = 4777T3625D;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					VK_USE_PLATFORM_IOS_MVK,
+					VK_ENABLE_BETA_EXTENSIONS,
+				);
+				HEADER_SEARCH_PATHS = (
+					"\"$(SRCROOT)/../../build/Vulkan-Headers/include\"",
+					"\"$(SRCROOT)/../generated\"",
+					"\"$(SRCROOT)/..\"",
+					"\"$(SRCROOT)/vulkaninfo\"",
+				);
+				INFOPLIST_FILE = vulkaninfo/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.lunarg.vulkaninfo;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SUPPORTS_MACCATALYST = YES;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		A07BD427255B45E000B79448 /* Build configuration list for PBXProject "vulkaninfo" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				A07BD443255B45E200B79448 /* Debug */,
+				A07BD444255B45E200B79448 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		A07BD445255B45E200B79448 /* Build configuration list for PBXNativeTarget "vulkaninfo" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				A07BD446255B45E200B79448 /* Debug */,
+				A07BD447255B45E200B79448 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = A07BD424255B45E000B79448 /* Project object */;
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/contents.xcworkspacedata
new file mode 100644
index 00000000..919434a6
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/contents.xcworkspacedata
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
+</Workspace>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
new file mode 100644
index 00000000..18d98100
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/xcuserdata/lunarg.xcuserdatad/UserInterfaceState.xcuserstate b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/xcuserdata/lunarg.xcuserdatad/UserInterfaceState.xcuserstate
new file mode 100644
index 00000000..dceb7e8c
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/xcuserdata/lunarg.xcuserdatad/UserInterfaceState.xcuserstate
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/xcuserdata/lunarg.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/xcuserdata/lunarg.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist
new file mode 100644
index 00000000..5f774687
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/xcuserdata/lunarg.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist
@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Bucket
+   uuid = "CD03A52F-70EE-4CA8-8A04-AA37042731C8"
+   type = "1"
+   version = "2.0">
+   <Breakpoints>
+      <BreakpointProxy
+         BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
+         <BreakpointContent
+            uuid = "0A318E23-A354-4504-B62D-377DC59080FC"
+            shouldBeEnabled = "No"
+            ignoreCount = "0"
+            continueAfterRunningActions = "No"
+            filePath = "../vulkaninfo.cpp"
+            startingColumnNumber = "9223372036854775807"
+            endingColumnNumber = "9223372036854775807"
+            startingLineNumber = "969"
+            endingLineNumber = "969"
+            landmarkName = "vulkanInfoMain(argc, argv)"
+            landmarkType = "9">
+         </BreakpointContent>
+      </BreakpointProxy>
+      <BreakpointProxy
+         BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
+         <BreakpointContent
+            uuid = "2D991475-1A1D-4A97-A2CB-F3FBBA80BC4E"
+            shouldBeEnabled = "No"
+            ignoreCount = "0"
+            continueAfterRunningActions = "No"
+            filePath = "vulkaninfo/ViewController.m"
+            startingColumnNumber = "9223372036854775807"
+            endingColumnNumber = "9223372036854775807"
+            startingLineNumber = "39"
+            endingLineNumber = "39"
+            landmarkName = "-viewDidLoad"
+            landmarkType = "7">
+         </BreakpointContent>
+      </BreakpointProxy>
+      <BreakpointProxy
+         BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
+         <BreakpointContent
+            uuid = "28380D7E-73BC-4B38-837F-7CCA9B35B00B"
+            shouldBeEnabled = "No"
+            ignoreCount = "0"
+            continueAfterRunningActions = "No"
+            filePath = "../outputprinter.h"
+            startingColumnNumber = "9223372036854775807"
+            endingColumnNumber = "9223372036854775807"
+            startingLineNumber = "306"
+            endingLineNumber = "306"
+            landmarkName = "ObjectStart(object_name)"
+            landmarkType = "7">
+         </BreakpointContent>
+      </BreakpointProxy>
+      <BreakpointProxy
+         BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
+         <BreakpointContent
+            uuid = "B192D664-BFF2-4B2B-820F-815D8B2EFDAB"
+            shouldBeEnabled = "No"
+            ignoreCount = "0"
+            continueAfterRunningActions = "No"
+            filePath = "../outputprinter.h"
+            startingColumnNumber = "9223372036854775807"
+            endingColumnNumber = "9223372036854775807"
+            startingLineNumber = "406"
+            endingLineNumber = "406"
+            landmarkName = "ArrayStart(array_name)"
+            landmarkType = "7">
+         </BreakpointContent>
+      </BreakpointProxy>
+   </Breakpoints>
+</Bucket>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/xcuserdata/lunarg.xcuserdatad/xcschemes/xcschememanagement.plist b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/xcuserdata/lunarg.xcuserdatad/xcschemes/xcschememanagement.plist
new file mode 100644
index 00000000..13496336
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/xcuserdata/lunarg.xcuserdatad/xcschemes/xcschememanagement.plist
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>SchemeUserState</key>
+	<dict>
+		<key>vulkaninfo.xcscheme_^#shared#^_</key>
+		<dict>
+			<key>orderHint</key>
+			<integer>0</integer>
+		</dict>
+	</dict>
+</dict>
+</plist>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/AppDelegate.h b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/AppDelegate.h
new file mode 100644
index 00000000..69d01817
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/AppDelegate.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import <UIKit/UIKit.h>
+
+@interface AppDelegate : UIResponder <UIApplicationDelegate>
+
+@end
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/AppDelegate.m b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/AppDelegate.m
new file mode 100644
index 00000000..e8c0e3f4
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/AppDelegate.m
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import "AppDelegate.h"
+
+@interface AppDelegate ()
+
+@end
+
+@implementation AppDelegate
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
+    // Override point for customization after application launch.
+    return YES;
+}
+
+#pragma mark - UISceneSession lifecycle
+
+- (UISceneConfiguration *)application:(UIApplication *)application
+    configurationForConnectingSceneSession:(UISceneSession *)connectingSceneSession
+                                   options:(UISceneConnectionOptions *)options {
+    // Called when a new scene session is being created.
+    // Use this method to select a configuration to create the new scene with.
+    return [[UISceneConfiguration alloc] initWithName:@"Default Configuration" sessionRole:connectingSceneSession.role];
+}
+
+- (void)application:(UIApplication *)application didDiscardSceneSessions:(NSSet<UISceneSession *> *)sceneSessions {
+    // Called when the user discards a scene session.
+    // If any sessions were discarded while the application was not running, this will be called shortly after
+    // application:didFinishLaunchingWithOptions. Use this method to release any resources that were specific to the discarded
+    // scenes, as they will not return.
+}
+
+@end
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AccentColor.colorset/Contents.json b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AccentColor.colorset/Contents.json
new file mode 100644
index 00000000..eb878970
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AccentColor.colorset/Contents.json
@@ -0,0 +1,11 @@
+{
+  "colors" : [
+    {
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/Contents.json b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/Contents.json
new file mode 100644
index 00000000..efcf4234
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/Contents.json
@@ -0,0 +1,103 @@
+{
+  "images" : [
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "filename" : "VulkanLogo120-1.png",
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "40x40"
+    },
+    {
+      "filename" : "VulkanLogo120.png",
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "60x60"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "60x60"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "76x76"
+    },
+    {
+      "filename" : "VulkanLogo152.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "76x76"
+    },
+    {
+      "filename" : "VulkanLogo167.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "83.5x83.5"
+    },
+    {
+      "filename" : "VulkanAppLogo1024.png",
+      "idiom" : "ios-marketing",
+      "scale" : "1x",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanAppLogo1024.png b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanAppLogo1024.png
new file mode 100644
index 00000000..3c8f2282
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanAppLogo1024.png
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo120-1.png b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo120-1.png
new file mode 100644
index 00000000..04126379
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo120-1.png
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo120.png b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo120.png
new file mode 100644
index 00000000..04126379
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo120.png
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo152.png b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo152.png
new file mode 100644
index 00000000..23e503d2
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo152.png
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo167.png b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo167.png
new file mode 100644
index 00000000..1545d57b
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo167.png
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/Contents.json b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/Contents.json
new file mode 100644
index 00000000..73c00596
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/Contents.json
@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Base.lproj/LaunchScreen.storyboard b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Base.lproj/LaunchScreen.storyboard
new file mode 100644
index 00000000..865e9329
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Base.lproj/LaunchScreen.storyboard
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="13122.16" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13104.12"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="EHf-IW-A2E">
+            <objects>
+                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                        <rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <color key="backgroundColor" xcode11CocoaTouchSystemColor="systemBackgroundColor" cocoaTouchSystemColor="whiteColor"/>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="53" y="375"/>
+        </scene>
+    </scenes>
+</document>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Base.lproj/Main.storyboard b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Base.lproj/Main.storyboard
new file mode 100644
index 00000000..876d52ae
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Base.lproj/Main.storyboard
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="17506" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="BYZ-38-t0r">
+    <device id="retina6_1" orientation="portrait" appearance="light"/>
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="17505"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="System colors in document resources" minToolsVersion="11.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="tne-QT-ifu">
+            <objects>
+                <viewController id="BYZ-38-t0r" customClass="ViewController" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="8bC-Xf-vdC">
+                        <rect key="frame" x="0.0" y="0.0" width="414" height="896"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <subviews>
+                            <wkWebView contentMode="scaleToFill" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="mvS-oO-lQz">
+                                <rect key="frame" x="0.0" y="34" width="414" height="820"/>
+                                <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                                <color key="backgroundColor" red="0.36078431370000003" green="0.38823529410000002" blue="0.4039215686" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+                                <wkWebViewConfiguration key="configuration">
+                                    <audiovisualMediaTypes key="mediaTypesRequiringUserActionForPlayback" none="YES"/>
+                                    <wkPreferences key="preferences"/>
+                                </wkWebViewConfiguration>
+                            </wkWebView>
+                        </subviews>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                        <color key="backgroundColor" systemColor="systemBackgroundColor"/>
+                    </view>
+                    <connections>
+                        <outlet property="webView" destination="mvS-oO-lQz" id="Hyq-NC-6lo"/>
+                    </connections>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="dkx-z0-nzr" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="13.043478260869566" y="79.6875"/>
+        </scene>
+    </scenes>
+    <resources>
+        <systemColor name="systemBackgroundColor">
+            <color white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+        </systemColor>
+    </resources>
+</document>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Info.plist b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Info.plist
new file mode 100644
index 00000000..2d3a4b00
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Info.plist
@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>LSApplicationCategoryType</key>
+	<string></string>
+	<key>LSRequiresIPhoneOS</key>
+	<false/>
+	<key>UIApplicationSceneManifest</key>
+	<dict>
+		<key>UIApplicationSupportsMultipleScenes</key>
+		<false/>
+		<key>UISceneConfigurations</key>
+		<dict>
+			<key>UIWindowSceneSessionRoleApplication</key>
+			<array>
+				<dict>
+					<key>UISceneConfigurationName</key>
+					<string>Default Configuration</string>
+					<key>UISceneDelegateClassName</key>
+					<string>SceneDelegate</string>
+					<key>UISceneStoryboardFile</key>
+					<string>Main</string>
+				</dict>
+			</array>
+		</dict>
+	</dict>
+	<key>UIApplicationSupportsIndirectInputEvents</key>
+	<true/>
+	<key>UIFileSharingEnabled</key>
+	<true/>
+	<key>UILaunchStoryboardName</key>
+	<string>LaunchScreen</string>
+	<key>UIMainStoryboardFile</key>
+	<string>Main</string>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>armv7</string>
+	</array>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+	</array>
+	<key>UISupportedInterfaceOrientations~ipad</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+</dict>
+</plist>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/SceneDelegate.h b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/SceneDelegate.h
new file mode 100644
index 00000000..39934557
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/SceneDelegate.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import <UIKit/UIKit.h>
+
+@interface SceneDelegate : UIResponder <UIWindowSceneDelegate>
+
+@property(strong, nonatomic) UIWindow* window;
+
+@end
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/SceneDelegate.m b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/SceneDelegate.m
new file mode 100644
index 00000000..8188b717
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/SceneDelegate.m
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import "SceneDelegate.h"
+
+@interface SceneDelegate ()
+
+@end
+
+@implementation SceneDelegate
+
+- (void)scene:(UIScene *)scene
+    willConnectToSession:(UISceneSession *)session
+                 options:(UISceneConnectionOptions *)connectionOptions {
+    // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
+    // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
+    // This delegate does not imply the connecting scene or session are new (see
+    // `application:configurationForConnectingSceneSession` instead).
+}
+
+- (void)sceneDidDisconnect:(UIScene *)scene {
+    // Called as the scene is being released by the system.
+    // This occurs shortly after the scene enters the background, or when its session is discarded.
+    // Release any resources associated with this scene that can be re-created the next time the scene connects.
+    // The scene may re-connect later, as its session was not necessarily discarded (see `application:didDiscardSceneSessions`
+    // instead).
+}
+
+- (void)sceneDidBecomeActive:(UIScene *)scene {
+    // Called when the scene has moved from an inactive state to an active state.
+    // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
+}
+
+- (void)sceneWillResignActive:(UIScene *)scene {
+    // Called when the scene will move from an active state to an inactive state.
+    // This may occur due to temporary interruptions (ex. an incoming phone call).
+}
+
+- (void)sceneWillEnterForeground:(UIScene *)scene {
+    // Called as the scene transitions from the background to the foreground.
+    // Use this method to undo the changes made on entering the background.
+}
+
+- (void)sceneDidEnterBackground:(UIScene *)scene {
+    // Called as the scene transitions from the foreground to the background.
+    // Use this method to save data, release shared resources, and store enough scene-specific state information
+    // to restore the scene back to its current state.
+}
+
+@end
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/ViewController.h b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/ViewController.h
new file mode 100644
index 00000000..f897dc9a
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/ViewController.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import <UIKit/UIKit.h>
+#import <WebKit/WKWebView.h>
+
+@interface ViewController : UIViewController
+
+@property(weak, nonatomic) IBOutlet WKWebView *webView;
+
+@end
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/ViewController.m b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/ViewController.m
new file mode 100644
index 00000000..573c7da0
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/ViewController.m
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import "ViewController.h"
+
+@interface ViewController ()
+
+@end
+
+@implementation ViewController
+
+- (void)viewDidLoad {
+    [super viewDidLoad];
+
+    // Get the HTML version of the output and display it in a web view.
+    NSArray *docPath = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+    NSString *myPath = [docPath objectAtIndex:0];
+    NSString *filePath = [myPath stringByAppendingPathComponent:@"/vulkaninfo.html"];
+
+    NSURL *url = [NSURL fileURLWithPath:filePath];
+    [webView loadFileURL:url allowingReadAccessToURL:url.URLByDeletingLastPathComponent];
+}
+
+@synthesize webView;
+
+@end
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/main.mm b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/main.mm
new file mode 100644
index 00000000..0643a490
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/main.mm
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import <UIKit/UIKit.h>
+#import "AppDelegate.h"
+
+int vulkanInfoMain(int argc, char **argv);
+
+int main(int argc, char *argv[]) {
+    // First thing we are going to "run" vulkaninfo to create the file output
+    // So that we don't have to touch the C++ desktop code, we'll set the current working directory
+    // to the shared documents folder where we are allowed to create and store files
+    NSArray *docPath = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+    NSString *myPath = [docPath objectAtIndex:0];
+    chdir([myPath UTF8String]);
+
+    // HTML Version
+    const char *htmlArgs[2] = {"vulkaninfo", "--html"};
+    vulkanInfoMain(2, (char **)htmlArgs);
+
+    // JSON output
+    const char *jsonArgs[2] = {"vulkaninfo", "--json"};
+    vulkanInfoMain(2, (char **)jsonArgs);
+
+    const char *portArgs[2] = {"vulkaninfo", "--portability"};
+    vulkanInfoMain(2, (char **)portArgs);
+
+    NSString *appDelegateClassName;
+    @autoreleasepool {
+        // Setup code that might create autoreleased objects goes here.
+        appDelegateClassName = NSStringFromClass([AppDelegate class]);
+    }
+    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/metal_iosview.h b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/metal_iosview.h
new file mode 100644
index 00000000..ebeacaf2
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/metal_iosview.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2018-2020 The Khronos Group Inc.
+ * Copyright (c) 2018-2020 Valve Corporation
+ * Copyright (c) 2018-2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Jeremy Kniager <jeremyk@lunarg.com>
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#ifndef metal_iosview_h
+#define metal_iosview_h
+
+void* CreateMetalView(uint32_t width, uint32_t height);
+
+void DestroyMetalView(void* view);
+
+void* GetCAMetalLayerFromMetalView(void* view);
+
+#endif /* metal_view_h */
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/metal_iosview.m b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/metal_iosview.m
new file mode 100644
index 00000000..df0d4f1f
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/metal_iosview.m
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2018-2020 The Khronos Group Inc.
+ * Copyright (c) 2018-2020 Valve Corporation
+ * Copyright (c) 2018-2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Jeremy Kniager <jeremyk@lunarg.com>
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import <UIKit/UIKit.h>
+
+@interface NativeMetalView : UIView
+@end
+
+@implementation NativeMetalView
+- (id)init:(CGRect)frame {
+    self = [super initWithFrame:frame];
+    return self;
+}
+
++ (Class)layerClass {
+    return [CAMetalLayer class];
+}
+
+- (CALayer*)makeBackingLayer {
+    CALayer* layer = [self.class.layerClass layer];
+    // CGSize viewScale = [self convertSizeToBacking:CGSizeMake(1.0, 1.0)];
+    // layer.contentsScale = MIN(viewScale.width, viewScale.height);
+    return layer;
+}
+@end
+
+NativeMetalView* CreateMetalView(uint32_t width, uint32_t height) {
+    return [[NativeMetalView alloc] initWithFrame:CGRectMake(0, 0, width, height)];
+}
+
+// void DestroyMetalView(void* view) { [(NativeMetalView*)view dealloc]; }
+
+CAMetalLayer* GetCAMetalLayerFromMetalView(NativeMetalView* view) { return (CAMetalLayer*)view.layer; }
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/vulkaninfo.entitlements b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/vulkaninfo.entitlements
new file mode 100644
index 00000000..ee95ab7e
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/vulkaninfo.entitlements
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.security.app-sandbox</key>
+	<true/>
+	<key>com.apple.security.network.client</key>
+	<true/>
+</dict>
+</plist>
diff --git a/tools/Vulkan-Tools/vulkaninfo/json_validation_process.md b/tools/Vulkan-Tools/vulkaninfo/json_validation_process.md
new file mode 100644
index 00000000..32df4f6f
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/json_validation_process.md
@@ -0,0 +1,24 @@
+# Validating [vulkaninfo](https://github.com/KhronosGroup/Vulkan-Tools/tree/main/vulkaninfo) JSON output
+
+The format of vulkaninfo's JSON output is designed to be used as input for the
+[Vulkan Profiles](https://github.com/KhronosGroup/Vulkan-Profiles)
+solution.
+
+The Vulkan Profiles JSON schema specifies exactly how the JSON must be structured.
+The schemas may be found at [here](https://schema.khronos.org/vulkan/).
+Select the latest schema that `vulkaninfo` was designed to be used with, or simply take the latest available schema.
+
+## Steps to validate JSON data against the Vulkan Profiles schema
+
+1. Generate the text to be tested using `vulkaninfo --json` which creates a `.json` file automatically.
+1. Download the [Vulkan Profiles schema](https://schema.khronos.org/vulkan/) to another file.
+1. For each of the on-line JSON validator tools listed below:
+   1. Paste the schema and and sample text into the `schema` and `data` fields.
+   1. Depending on the tool, it may validate automatically, or require clicking a `validate` button.
+   1. Ensure the tool reports no errors.
+
+## List of recommended JSON validator tools
+
+* https://www.jsonschemavalidator.net/
+* https://jsonschemalint.com/#/version/draft-04/markup/json
+* https://json-schema-validator.herokuapp.com/index.jsp
diff --git a/tools/Vulkan-Tools/vulkaninfo/macOS/vulkaninfo/metal_view.h b/tools/Vulkan-Tools/vulkaninfo/macOS/vulkaninfo/metal_view.h
new file mode 100644
index 00000000..31429d41
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/macOS/vulkaninfo/metal_view.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Valve Corporation
+ * Copyright (c) 2018 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Jeremy Kniager <jeremyk@lunarg.com>
+ */
+
+#ifndef metal_view_h
+#define metal_view_h
+
+void* CreateMetalView(uint32_t width, uint32_t height);
+
+void DestroyMetalView(void* view);
+
+void* GetCAMetalLayerFromMetalView(void* view);
+
+#endif /* metal_view_h */
diff --git a/tools/Vulkan-Tools/vulkaninfo/macOS/vulkaninfo/metal_view.mm b/tools/Vulkan-Tools/vulkaninfo/macOS/vulkaninfo/metal_view.mm
new file mode 100644
index 00000000..90bff4c5
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/macOS/vulkaninfo/metal_view.mm
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Valve Corporation
+ * Copyright (c) 2018 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Jeremy Kniager <jeremyk@lunarg.com>
+ */
+
+#import <AppKit/AppKit.h>
+#import <QuartzCore/QuartzCore.h>
+
+@interface NativeMetalView : NSView
+@end
+
+@implementation NativeMetalView
+- (id)initWithFrame:(NSRect)frame {
+    if (self = [super initWithFrame:frame]) {
+        self.wantsLayer = YES;
+    }
+    return self;
+}
+
++ (Class)layerClass {
+    return [CAMetalLayer class];
+}
+
+- (CALayer*)makeBackingLayer {
+    CALayer* layer = [self.class.layerClass layer];
+    CGSize viewScale = [self convertSizeToBacking:CGSizeMake(1.0, 1.0)];
+    layer.contentsScale = MIN(viewScale.width, viewScale.height);
+    return layer;
+}
+@end
+
+void* CreateMetalView(uint32_t width, uint32_t height) {
+    return [[NativeMetalView alloc] initWithFrame:NSMakeRect(0, 0, width, height)];
+}
+
+void DestroyMetalView(void* view) { [(NativeMetalView*)view dealloc]; }
+
+void* GetCAMetalLayerFromMetalView(void* view) { return ((NativeMetalView*)view).layer; }
diff --git a/tools/Vulkan-Tools/vulkaninfo/outputprinter.h b/tools/Vulkan-Tools/vulkaninfo/outputprinter.h
new file mode 100644
index 00000000..8255e928
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/outputprinter.h
@@ -0,0 +1,829 @@
+/*
+ * Copyright (c) 2019 The Khronos Group Inc.
+ * Copyright (c) 2019 Valve Corporation
+ * Copyright (c) 2019 LunarG, Inc.
+ * Copyright (c) 2023 RasterGrid Kft.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Charles Giessen <charles@lunarg.com>
+ *
+ */
+
+#pragma once
+
+#include <iomanip>
+#include <iostream>
+#include <ostream>
+#include <stack>
+#include <sstream>
+#include <string>
+
+#include <assert.h>
+
+#include "vulkaninfo.h"
+
+std::string insert_quotes(std::string s) { return "\"" + s + "\""; }
+
+std::string to_string(const std::array<uint8_t, 16> &uid) {
+    std::stringstream ss;
+    ss << std::hex << std::setfill('0');
+    for (int i = 0; i < 16; ++i) {
+        if (i == 4 || i == 6 || i == 8 || i == 10) ss << '-';
+        ss << std::setw(2) << static_cast<unsigned>(uid[i]);
+    }
+    return ss.str();
+}
+std::string to_string(const std::array<uint8_t, 8> &uid) {
+    std::stringstream ss;
+    ss << std::hex << std::setfill('0');
+    for (int i = 0; i < 8; ++i) {
+        if (i == 4) ss << '-';
+        ss << std::setw(2) << static_cast<unsigned>(uid[i]);
+    }
+    return ss.str();
+}
+
+std::ostream &operator<<(std::ostream &out, const VkConformanceVersion &v) {
+    return out << static_cast<unsigned>(v.major) << "." << static_cast<unsigned>(v.minor) << "."
+               << static_cast<unsigned>(v.subminor) << "." << static_cast<unsigned>(v.patch);
+}
+
+enum class OutputType { text, html, json, vkconfig_output };
+
+struct PrinterCreateDetails {
+    OutputType output_type = OutputType::text;
+    bool print_to_file = false;
+    std::string file_name = APP_SHORT_NAME ".txt";
+    std::string start_string = "";
+};
+
+class Printer {
+  public:
+    Printer(const PrinterCreateDetails &details, std::ostream &out, const APIVersion vulkan_version)
+        : output_type(details.output_type), out(out) {
+        StackNode node{};
+        node.is_first_item = false;
+        node.indents = 0;
+        switch (output_type) {
+            case (OutputType::text):
+                out << std::string(strlen(APP_UPPER_CASE_NAME), '=') << "\n";
+                out << APP_UPPER_CASE_NAME "\n";
+                out << std::string(strlen(APP_UPPER_CASE_NAME), '=') << "\n\n";
+                out << API_NAME " Instance Version: " << APIVersion(vulkan_version) << "\n\n\n";
+                break;
+            case (OutputType::html):
+                out << "<!doctype html>\n";
+                out << "<html lang='en'>\n";
+                out << "\t<head>\n";
+                out << "\t\t<title>" APP_SHORT_NAME "</title>\n";
+                out << "\t\t<style>\n";
+                out << "\t\thtml {\n";
+                out << "\t\t\tbackground-color: #0b1e48;\n";
+                out << "\t\t\tbackground-image: url(\"https://vulkan.lunarg.com/img/bg-starfield.jpg\");\n";
+                out << "\t\t\tbackground-position: center;\n";
+                out << "\t\t\t-webkit-background-size: cover;\n";
+                out << "\t\t\t-moz-background-size: cover;\n";
+                out << "\t\t\t-o-background-size: cover;\n";
+                out << "\t\t\tbackground-size: cover;\n";
+                out << "\t\t\tbackground-attachment: fixed;\n";
+                out << "\t\t\tbackground-repeat: no-repeat;\n";
+                out << "\t\t\theight: 100%;\n";
+                out << "\t\t}\n";
+                out << "\t\t#header {\n";
+                out << "\t\t\tz-index: -1;\n";
+                out << "\t\t}\n";
+                out << "\t\t#header>img {\n";
+                out << "\t\t\tposition: absolute;\n";
+                out << "\t\t\twidth: 160px;\n";
+                out << "\t\t\tmargin-left: -280px;\n";
+                out << "\t\t\ttop: -10px;\n";
+                out << "\t\t\tleft: 50%;\n";
+                out << "\t\t}\n";
+                out << "\t\t#header>h1 {\n";
+                out << "\t\t\tfont-family: Arial, \"Helvetica Neue\", Helvetica, sans-serif;\n";
+                out << "\t\t\tfont-size: 44px;\n";
+                out << "\t\t\tfont-weight: 200;\n";
+                out << "\t\t\ttext-shadow: 4px 4px 5px #000;\n";
+                out << "\t\t\tcolor: #eee;\n";
+                out << "\t\t\tposition: absolute;\n";
+                out << "\t\t\twidth: 400px;\n";
+                out << "\t\t\tmargin-left: -80px;\n";
+                out << "\t\t\ttop: 8px;\n";
+                out << "\t\t\tleft: 50%;\n";
+                out << "\t\t}\n";
+                out << "\t\tbody {\n";
+                out << "\t\t\tfont-family: Consolas, monaco, monospace;\n";
+                out << "\t\t\tfont-size: 14px;\n";
+                out << "\t\t\tline-height: 20px;\n";
+                out << "\t\t\tcolor: #eee;\n";
+                out << "\t\t\theight: 100%;\n";
+                out << "\t\t\tmargin: 0;\n";
+                out << "\t\t\toverflow: hidden;\n";
+                out << "\t\t}\n";
+                out << "\t\t#wrapper {\n";
+                out << "\t\t\tbackground-color: rgba(0, 0, 0, 0.7);\n";
+                out << "\t\t\tborder: 1px solid #446;\n";
+                out << "\t\t\tbox-shadow: 0px 0px 10px #000;\n";
+                out << "\t\t\tpadding: 8px 12px;\n\n";
+                out << "\t\t\tdisplay: inline-block;\n";
+                out << "\t\t\tposition: absolute;\n";
+                out << "\t\t\ttop: 80px;\n";
+                out << "\t\t\tbottom: 25px;\n";
+                out << "\t\t\tleft: 50px;\n";
+                out << "\t\t\tright: 50px;\n";
+                out << "\t\t\toverflow: auto;\n";
+                out << "\t\t}\n";
+                out << "\t\tdetails>details {\n";
+                out << "\t\t\tmargin-left: 22px;\n";
+                out << "\t\t}\n";
+                out << "\t\tdetails>summary:only-child::-webkit-details-marker {\n";
+                out << "\t\t\tdisplay: none;\n";
+                out << "\t\t}\n";
+                out << "\t\t.var, .type, .val {\n";
+                out << "\t\t\tdisplay: inline;\n";
+                out << "\t\t}\n";
+                out << "\t\t.var {\n";
+                out << "\t\t}\n";
+                out << "\t\t.type {\n";
+                out << "\t\t\tcolor: #acf;\n";
+                out << "\t\t\tmargin: 0 12px;\n";
+                out << "\t\t}\n";
+                out << "\t\t.val {\n";
+                out << "\t\t\tcolor: #afa;\n";
+                out << "\t\t\tbackground: #222;\n";
+                out << "\t\t\ttext-align: right;\n";
+                out << "\t\t}\n";
+                out << "\t\t</style>\n";
+                out << "\t</head>\n";
+                out << "\t<body>\n";
+                out << "\t\t<div id='header'>\n";
+                out << "\t\t\t<h1>" APP_SHORT_NAME "</h1>\n";
+                out << "\t\t</div>\n";
+                out << "\t\t<div id='wrapper'>\n";
+                out << "\t\t\t<details><summary>" API_NAME " Instance Version: <span class='val'>" << APIVersion(vulkan_version)
+                    << "</span></summary></details>\n\t\t\t<br />\n";
+                node.indents = 3;
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                out << details.start_string;
+                node.indents = 1;
+                break;
+            default:
+                break;
+        }
+        object_stack.push(node);
+    }
+    ~Printer() {
+        switch (output_type) {
+            case (OutputType::text):
+                break;
+            case (OutputType::html):
+                out << "\t\t</div>\n";
+                out << "\t</body>\n";
+                out << "</html>\n";
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                out << "\n}\n";
+                break;
+        }
+        assert(!object_stack.empty() && "mismatched number of ObjectStart/ObjectEnd or ArrayStart/ArrayEnd's");
+        object_stack.pop();
+        assert(object_stack.empty() && "indents must be zero at program end");
+    };
+
+    Printer(const Printer &) = delete;
+    const Printer &operator=(const Printer &) = delete;
+
+    OutputType Type() { return output_type; }
+
+    // When an error occurs, call this to create a valid output file. Needed for json/html
+    void FinishOutput() {
+        while (!object_stack.empty()) {
+            switch (output_type) {
+                case (OutputType::text):
+                    break;
+                case (OutputType::html):
+                    while (get_top().indents > 3) {
+                        out << "</details>\n";
+                    }
+                    break;
+                case (OutputType::json):
+                case (OutputType::vkconfig_output):
+                    out << "\n" << std::string(static_cast<size_t>(get_top().indents), '\t');
+                    if (get_top().is_array) {
+                        out << "]";
+                    } else {
+                        out << "}";
+                    }
+                    break;
+                default:
+                    break;
+            }
+            object_stack.pop();
+        }
+    }
+
+    // Custom Formatting
+    // use by prepending with p.SetXXX().ObjectStart/ArrayStart
+
+    Printer &SetHeader() {
+        get_top().set_next_header = true;
+        return *this;
+    }
+
+    Printer &SetSubHeader() {
+        get_top().set_next_subheader = true;
+        return *this;
+    }
+
+    Printer &SetOpenDetails() {
+        get_top().set_details_open = true;
+        return *this;
+    }
+
+    Printer &SetAlwaysOpenDetails(bool value = true) {
+        get_top().should_always_open = value;
+        return *this;
+    }
+
+    Printer &SetTitleAsType() {
+        get_top().set_object_name_as_type = true;
+        return *this;
+    }
+
+    Printer &SetAsType() {
+        get_top().set_as_type = true;
+        return *this;
+    }
+
+    Printer &SetIgnoreMinWidthInChild() {
+        get_top().ignore_min_width_parameter_in_child = true;
+        return *this;
+    }
+
+    Printer &SetMinKeyWidth(size_t min_key_width) {
+        get_top().min_key_width = min_key_width;
+        return *this;
+    }
+
+    Printer &SetElementIndex(int index) {
+        assert(index >= 0 && "cannot set element index to a negative value");
+        get_top().element_index = index;
+        return *this;
+    }
+    Printer &SetValueDescription(std::string str) {
+        value_description = str;
+        return *this;
+    }
+
+    void ObjectStart(std::string object_name, int32_t count_subobjects = -1) {
+        switch (output_type) {
+            case (OutputType::text): {
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << object_name;
+                if (!value_description.empty()) {
+                    out << " (" << value_description << ")";
+                    value_description = {};
+                }
+                if (get_top().element_index != -1) {
+                    out << "[" << get_top().element_index << "]";
+                }
+                out << ":";
+                if (count_subobjects >= 0) {
+                    out << " count = " << count_subobjects;
+                }
+                out << "\n";
+                size_t headersize = object_name.size() + 1;
+                if (count_subobjects >= 0) {
+                    headersize += 9 + std::to_string(count_subobjects).size();
+                }
+                if (get_top().element_index != -1) {
+                    headersize += 2 + std::to_string(get_top().element_index).size();
+                    get_top().element_index = -1;
+                }
+                PrintHeaderUnderlines(headersize);
+                break;
+            }
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t');
+                if (get_top().set_details_open || get_top().should_always_open) {
+                    out << "<details open>";
+                    get_top().set_details_open = false;
+                } else {
+                    out << "<details>";
+                }
+                out << "<summary>";
+                if (get_top().set_object_name_as_type) {
+                    out << "<span class='type'>" << object_name << "</span>";
+                    get_top().set_object_name_as_type = false;
+                } else {
+                    out << object_name;
+                }
+                if (!value_description.empty()) {
+                    out << " (" << value_description << ")";
+                    value_description = {};
+                }
+                if (get_top().element_index != -1) {
+                    out << "[<span class='val'>" << get_top().element_index << "</span>]";
+                    get_top().element_index = -1;
+                }
+                if (count_subobjects >= 0) {
+                    out << ": count = <span class='val'>" << std::to_string(count_subobjects) << "</span>";
+                }
+                out << "</summary>\n";
+                break;
+            case (OutputType::json):
+                if (!get_top().is_first_item) {
+                    out << ",\n";
+                } else {
+                    get_top().is_first_item = false;
+                }
+                out << std::string(static_cast<size_t>(get_top().indents), '\t');
+                // Objects with no name are elements in an array of objects
+                if (get_top().is_array || object_name == "" || get_top().element_index != -1) {
+                    out << "{\n";
+                    get_top().element_index = -1;
+                } else {
+                    out << "\"" << object_name << "\": {\n";
+                }
+                if (!value_description.empty()) {
+                    value_description = {};
+                }
+                break;
+            case (OutputType::vkconfig_output):
+                if (!get_top().is_first_item) {
+                    out << ",\n";
+                } else {
+                    get_top().is_first_item = false;
+                }
+                out << std::string(static_cast<size_t>(get_top().indents), '\t');
+
+                if (get_top().is_array && get_top().element_index != -1) {
+                    out << "\"" << object_name << "[" << get_top().element_index << "]\": ";
+                    get_top().element_index = -1;
+                } else if (!get_top().is_array) {
+                    out << "\"" << object_name << "\": ";
+                }
+                out << "{\n";
+                if (!value_description.empty()) {
+                    value_description = {};
+                }
+                break;
+            default:
+                break;
+        }
+        push_node(false);
+    }
+    void ObjectEnd() {
+        assert(get_top().is_array == false && "cannot call ObjectEnd while inside an Array");
+        object_stack.pop();
+        assert(get_top().indents >= 0 && "indents cannot go below zero");
+        switch (output_type) {
+            case (OutputType::text):
+
+                break;
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << "</details>\n";
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                out << "\n" << std::string(static_cast<size_t>(get_top().indents), '\t') << "}";
+                break;
+            default:
+                break;
+        }
+    }
+    void ArrayStart(std::string array_name, size_t element_count = 0) {
+        switch (output_type) {
+            case (OutputType::text): {
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << array_name << ":";
+                size_t underline_count = array_name.size() + 1;
+                if (element_count > 0) {
+                    out << " count = " << element_count;
+                    underline_count += 9 + std::to_string(element_count).size();
+                }
+                out << "\n";
+                PrintHeaderUnderlines(underline_count);
+                break;
+            }
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t');
+                if (get_top().set_details_open || get_top().should_always_open) {
+                    out << "<details open>";
+                    get_top().set_details_open = false;
+                } else {
+                    out << "<details>";
+                }
+                out << "<summary>" << array_name;
+                if (element_count > 0) {
+                    out << ": count = <span class='val'>" << element_count << "</span>";
+                }
+                out << "</summary>\n";
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                if (!get_top().is_first_item) {
+                    out << ",\n";
+                } else {
+                    get_top().is_first_item = false;
+                }
+                out << std::string(static_cast<size_t>(get_top().indents), '\t');
+                if (!get_top().is_array) {
+                    out << "\"" << array_name << "\": ";
+                }
+                out << "[\n";
+                break;
+            default:
+                break;
+        }
+        push_node(true);
+    }
+    void ArrayEnd() {
+        assert(get_top().is_array == true && "cannot call ArrayEnd while inside an Object");
+        object_stack.pop();
+        assert(get_top().indents >= 0 && "indents cannot go below zero");
+        switch (output_type) {
+            case (OutputType::text):
+                break;
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << "</details>\n";
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                out << "\n" << std::string(static_cast<size_t>(get_top().indents), '\t') << "]";
+                break;
+            default:
+                break;
+        }
+    }
+
+    // For printing key-value pairs.
+    // value_description is for reference information and is displayed inside parenthesis after the value
+    template <typename T>
+    void PrintKeyValue(std::string key, T value) {
+        // If we are inside of an array, Print the value as an element
+        if (get_top().is_array) {
+            PrintElement(value);
+            return;
+        }
+
+        switch (output_type) {
+            case (OutputType::text):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << key;
+                if (get_top().min_key_width > key.size() && !get_top().ignore_min_width_parameter) {
+                    out << std::string(get_top().min_key_width - key.size(), ' ');
+                }
+                out << " = " << value;
+                if (value_description != "") {
+                    out << " (" << value_description << ")";
+                    value_description = {};
+                }
+                out << "\n";
+                break;
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << "<details><summary>" << key;
+                if (get_top().min_key_width > key.size()) {
+                    out << std::string(get_top().min_key_width - key.size(), ' ');
+                }
+                if (get_top().set_as_type) {
+                    get_top().set_as_type = false;
+                    out << " = <span class='type'>" << value << "</span>";
+                } else {
+                    out << " = <span class='val'>" << value << "</span>";
+                }
+                if (!value_description.empty()) {
+                    out << " (<span class='val'>" << value_description << "</span>)";
+                    value_description = {};
+                }
+                out << "</summary></details>\n";
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                if (!get_top().is_first_item) {
+                    out << ",\n";
+                } else {
+                    get_top().is_first_item = false;
+                }
+                out << std::string(static_cast<size_t>(get_top().indents), '\t');
+                if (!get_top().is_array) {
+                    out << "\"" << key << "\": ";
+                }
+                if (!value_description.empty()) {
+                    out << "\"" << value << " (" << value_description << ")\"";
+                    value_description = {};
+                } else {
+                    out << value;
+                }
+            default:
+                break;
+        }
+    }
+
+    // Need a specialization to handle C style arrays since they are implicitly converted to pointers
+    template <size_t N>
+    void PrintKeyValue(std::string key, const uint8_t (&values)[N]) {
+        switch (output_type) {
+            case (OutputType::json): {
+                ArrayStart(key, N);
+                for (uint32_t i = 0; i < N; i++) {
+                    PrintElement(static_cast<uint32_t>(values[i]));
+                }
+                ArrayEnd();
+                break;
+            }
+            default: {
+                std::array<uint8_t, N> arr{};
+                std::copy(std::begin(values), std::end(values), std::begin(arr));
+                PrintKeyString(key, to_string(arr));
+                break;
+            }
+        }
+    }
+
+    // For printing key - string pairs (necessary because of json)
+    void PrintKeyString(std::string key, std::string value) {
+        switch (output_type) {
+            case (OutputType::text):
+            case (OutputType::html):
+                PrintKeyValue(key, value);
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                if (!value_description.empty()) {
+                    // PrintKeyValue adds the necessary quotes when printing with a value description set
+                    PrintKeyValue(key, EscapeJSONCString(value));
+                } else {
+                    PrintKeyValue(key, std::string("\"") + EscapeJSONCString(value) + "\"");
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    // For printing key - string pairs (necessary because of json)
+    void PrintKeyBool(std::string key, bool value) { PrintKeyValue(key, value ? "true" : "false"); }
+
+    // print inside array
+    template <typename T>
+    void PrintElement(T element) {
+        // If we are inside of an object, just use an empty string as the key
+        if (!get_top().is_array) {
+            PrintKeyValue("placeholder", element);
+            return;
+        }
+        switch (output_type) {
+            case (OutputType::text):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << element << "\n";
+                break;
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << "<details><summary>";
+                if (get_top().set_as_type) {
+                    get_top().set_as_type = false;
+                    out << "<span class='type'>" << element << "</span>";
+                } else {
+                    out << "<span class='val'>" << element << "</span>";
+                }
+                out << "</summary></details>\n";
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                if (!get_top().is_first_item) {
+                    out << ",\n";
+                } else {
+                    get_top().is_first_item = false;
+                }
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << element;
+                break;
+            default:
+                break;
+        }
+    }
+    void PrintString(std::string string) {
+        switch (output_type) {
+            case (OutputType::text):
+            case (OutputType::html):
+                PrintElement(string);
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                PrintElement("\"" + EscapeJSONCString(string) + "\"");
+            default:
+                break;
+        }
+    }
+    void PrintExtension(std::string ext_name, uint32_t revision, size_t min_width = 0) {
+        switch (output_type) {
+            case (OutputType::text):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << ext_name
+                    << std::string(min_width - ext_name.size(), ' ') << " : extension revision " << revision << "\n";
+                break;
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << "<details><summary>" << DecorateAsType(ext_name)
+                    << std::string(min_width - ext_name.size(), ' ') << " : extension revision "
+                    << DecorateAsValue(std::to_string(revision)) << "</summary></details>\n";
+                break;
+            case (OutputType::json):
+                PrintKeyValue(ext_name, revision);
+                break;
+            case (OutputType::vkconfig_output):
+                ObjectStart(ext_name);
+                PrintKeyValue("specVersion", revision);
+                ObjectEnd();
+                break;
+            default:
+                break;
+        }
+    }
+    void AddNewline() {
+        if (output_type == OutputType::text) {
+            out << "\n";
+        }
+    }
+    void IndentIncrease() {
+        if (output_type == OutputType::text) {
+            get_top().indents++;
+        }
+    }
+    void IndentDecrease() {
+        if (output_type == OutputType::text) {
+            get_top().indents--;
+            assert(get_top().indents >= 0 && "indents cannot go below zero");
+        }
+    }
+
+    std::string DecorateAsType(const std::string &input) {
+        if (output_type == OutputType::html)
+            return "<span class='type'>" + input + "</span>";
+        else
+            return input;
+    }
+
+    std::string DecorateAsValue(const std::string &input) {
+        if (output_type == OutputType::html)
+            return "<span class='val'>" + input + "</span>";
+        else
+            return input;
+    }
+
+  protected:
+    OutputType output_type;
+    std::ostream &out;
+
+    struct StackNode {
+        int indents = 0;
+
+        // header, subheader
+        bool set_next_header = false;
+        bool set_next_subheader = false;
+
+        // html coloring
+        bool set_as_type = false;
+
+        // open <details>
+        bool set_details_open = false;
+
+        // always open <details>
+        bool should_always_open = false;
+
+        // make object titles the color of types
+        bool set_object_name_as_type = false;
+
+        // ignores the min_width parameter
+        bool ignore_min_width_parameter = false;
+
+        // sets the next created object/child to ignore the min_width parameter
+        bool ignore_min_width_parameter_in_child = false;
+
+        // keep track of the spacing between names and values
+        size_t min_key_width = 0;
+
+        // objects which are in an array
+        int element_index = -1;  // negative one is the sentinel value
+
+        // json
+        bool is_first_item;  // for json: for adding a comma in between objects
+        bool is_array;       // for json: match pairs of {}'s and []'s
+    };
+
+    // Contains the details about the current 'object' in the tree
+    std::stack<StackNode> object_stack;
+
+    // Helper to get the current top of the object_stack
+    StackNode &get_top() { return object_stack.top(); }
+
+    // Optional 'description' for values
+    // Must be set right before the Print() function is called
+    std::string value_description;
+
+    // can only be called after a node was manually pushed onto the stack in the constructor
+    void push_node(bool array) {
+        StackNode node{};
+        node.indents = get_top().indents + 1;
+        node.is_array = array;
+        node.is_first_item = true;
+        node.ignore_min_width_parameter = get_top().ignore_min_width_parameter_in_child;
+        object_stack.push(node);
+    }
+
+    // utility
+    void PrintHeaderUnderlines(size_t length) {
+        assert(get_top().indents >= 0 && "indents must not be negative");
+        assert(length <= 10000 && "length shouldn't be unreasonably large");
+        if (get_top().set_next_header) {
+            out << std::string(static_cast<size_t>(get_top().indents), '\t') << std::string(length, '=') << "\n";
+            get_top().set_next_header = false;
+        } else if (get_top().set_next_subheader) {
+            out << std::string(static_cast<size_t>(get_top().indents), '\t') << std::string(length, '-') << "\n";
+            get_top().set_next_subheader = false;
+        }
+    }
+
+    // Replace special characters in strings with their escaped versions.
+    // <https://www.json.org/json-en.html>
+    std::string EscapeJSONCString(std::string string) {
+        if (output_type == OutputType::text || output_type == OutputType::html) return string;
+        std::string out{};
+        for (size_t i = 0; i < string.size(); i++) {
+            char c = string[i];
+            char out_c = c;
+            switch (c) {
+                case '\"':
+                case '\\':
+                    out.push_back('\\');
+                    break;
+                case '\b':
+                    out.push_back('\\');
+                    out_c = 'b';
+                    break;
+                case '\f':
+                    out.push_back('\\');
+                    out_c = 'f';
+                    break;
+                case '\n':
+                    out.push_back('\\');
+                    out_c = 'n';
+                    break;
+                case '\r':
+                    out.push_back('\\');
+                    out_c = 'r';
+                    break;
+                case '\t':
+                    out.push_back('\\');
+                    out_c = 't';
+                    break;
+            }
+            out.push_back(out_c);
+        }
+
+        return out;
+    }
+};
+// Purpose: When a Printer starts an object or array it will automatically indent the output. This isn't
+// always desired, requiring a manual decrease of indention. This wrapper facilitates that while also
+// automatically re-indenting the output to the previous indent level on scope exit.
+class IndentWrapper {
+  public:
+    IndentWrapper(Printer &p) : p(p) {
+        if (p.Type() == OutputType::text) p.IndentDecrease();
+    }
+    ~IndentWrapper() {
+        if (p.Type() == OutputType::text) p.IndentIncrease();
+    }
+
+  private:
+    Printer &p;
+};
+
+class ObjectWrapper {
+  public:
+    ObjectWrapper(Printer &p, std::string object_name) : p(p) { p.ObjectStart(object_name); }
+    ObjectWrapper(Printer &p, std::string object_name, size_t count_subobjects) : p(p) {
+        p.ObjectStart(object_name, static_cast<int32_t>(count_subobjects));
+    }
+    ~ObjectWrapper() { p.ObjectEnd(); }
+
+  private:
+    Printer &p;
+};
+
+class ArrayWrapper {
+  public:
+    ArrayWrapper(Printer &p, std::string array_name, size_t element_count = 0) : p(p) { p.ArrayStart(array_name, element_count); }
+    ~ArrayWrapper() { p.ArrayEnd(); }
+
+  private:
+    Printer &p;
+};
diff --git a/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.cpp b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.cpp
new file mode 100644
index 00000000..2c11226a
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.cpp
@@ -0,0 +1,1604 @@
+/*
+ * Copyright (c) 2015-2026 The Khronos Group Inc.
+ * Copyright (c) 2015-2026 Valve Corporation
+ * Copyright (c) 2015-2026 LunarG, Inc.
+ * Copyright (c) 2023-2024 RasterGrid Kft.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
+ * Author: David Pinedo <david@lunarg.com>
+ * Author: Mark Lobodzinski <mark@lunarg.com>
+ * Author: Rene Lindsay <rene@lunarg.com>
+ * Author: Jeremy Kniager <jeremyk@lunarg.com>
+ * Author: Shannon McPherson <shannon@lunarg.com>
+ * Author: Bob Ellison <bob@lunarg.com>
+ * Author: Richard Wright <richard@lunarg.com>
+ * Author: Charles Giessen <charles@lunarg.com>
+ *
+ */
+
+#include <string>
+#ifdef _WIN32
+#include <crtdbg.h>
+#endif
+#include "vulkaninfo.hpp"
+
+// Used to sort the formats into buckets by their properties.
+std::unordered_map<PropFlags, std::set<VkFormat>> FormatPropMap(AppGpu &gpu) {
+    std::unordered_map<PropFlags, std::set<VkFormat>> map;
+    for (const auto fmtRange : format_ranges) {
+        if (gpu.FormatRangeSupported(fmtRange)) {
+            for (int32_t fmt = fmtRange.first_format; fmt <= fmtRange.last_format; ++fmt) {
+                PropFlags pf = get_format_properties(gpu, static_cast<VkFormat>(fmt));
+                map[pf].insert(static_cast<VkFormat>(fmt));
+            }
+        }
+    }
+    return map;
+}
+
+// =========== Dump Functions ========= //
+
+void DumpExtensions(Printer &p, std::string section_name, std::vector<VkExtensionProperties> extensions, bool do_indent = false) {
+    std::sort(extensions.begin(), extensions.end(), [](VkExtensionProperties &a, VkExtensionProperties &b) -> int {
+        return std::string(a.extensionName) < std::string(b.extensionName);
+    });
+
+    size_t max_length = 0;
+    for (const auto &ext : extensions) {
+        max_length = std::max(max_length, std::strlen(ext.extensionName));
+    }
+#if defined(VK_ENABLE_BETA_EXTENSIONS)
+    const std::string portability_ext_name = VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME;
+#endif  // defined(VK_ENABLE_BETA_EXTENSIONS)
+    ObjectWrapper obj(p, section_name, extensions.size());
+    if (do_indent) p.IndentDecrease();
+    for (auto &ext : extensions) {
+#if defined(VK_ENABLE_BETA_EXTENSIONS)
+        if (p.Type() == OutputType::json && portability_ext_name == ext.extensionName) continue;
+#endif  // defined(VK_ENABLE_BETA_EXTENSIONS)
+        p.PrintExtension(ext.extensionName, ext.specVersion, max_length);
+    }
+    if (do_indent) p.IndentIncrease();
+}
+
+void DumpLayers(Printer &p, std::vector<LayerExtensionList> layers, const std::vector<std::unique_ptr<AppGpu>> &gpus) {
+    std::sort(layers.begin(), layers.end(), [](LayerExtensionList &left, LayerExtensionList &right) -> int {
+        return std::strncmp(left.layer_properties.layerName, right.layer_properties.layerName, VK_MAX_DESCRIPTION_SIZE) < 0;
+    });
+    switch (p.Type()) {
+        case OutputType::text:
+        case OutputType::html: {
+            p.SetHeader();
+            ArrayWrapper arr_layers(p, "Layers", layers.size());
+            IndentWrapper indent(p);
+
+            for (auto &layer : layers) {
+                std::string v_str = APIVersion(layer.layer_properties.specVersion);
+                auto props = layer.layer_properties;
+
+                std::string header = p.DecorateAsType(props.layerName) + " (" + props.description + ") " API_NAME " version " +
+                                     p.DecorateAsValue(v_str) + ", layer version " +
+                                     p.DecorateAsValue(std::to_string(props.implementationVersion));
+                ObjectWrapper obj(p, header);
+                DumpExtensions(p, "Layer Extensions", layer.extension_properties);
+
+                ObjectWrapper arr_devices(p, "Devices", gpus.size());
+                for (auto &gpu : gpus) {
+                    p.SetValueDescription(std::string(gpu->props.deviceName)).PrintKeyValue("GPU id", gpu->id);
+                    auto exts = gpu->inst.AppGetPhysicalDeviceLayerExtensions(gpu->phys_device, props.layerName);
+                    DumpExtensions(p, "Layer-Device Extensions", exts);
+                    p.AddNewline();
+                }
+            }
+            break;
+        }
+
+        case OutputType::json: {
+            assert(false && "unimplemented");
+            break;
+        }
+        case OutputType::vkconfig_output: {
+            ObjectWrapper obj(p, "Layer Properties");
+            for (auto &layer : layers) {
+                ObjectWrapper obj_name(p, layer.layer_properties.layerName);
+                p.SetMinKeyWidth(21);
+                p.PrintKeyString("layerName", layer.layer_properties.layerName);
+                p.PrintKeyString("version", APIVersion(layer.layer_properties.specVersion).str());
+                p.PrintKeyValue("implementation version", layer.layer_properties.implementationVersion);
+                p.PrintKeyString("description", layer.layer_properties.description);
+                DumpExtensions(p, "Layer Extensions", layer.extension_properties);
+                ObjectWrapper obj_devices(p, "Devices");
+                for (auto &gpu : gpus) {
+                    ObjectWrapper obj_gpu(p, gpu->props.deviceName);
+                    p.SetValueDescription(std::string(gpu->props.deviceName)).PrintKeyValue("GPU id", gpu->id);
+                    auto exts = gpu->inst.AppGetPhysicalDeviceLayerExtensions(gpu->phys_device, layer.layer_properties.layerName);
+                    DumpExtensions(p, "Layer-Device Extensions", exts);
+                }
+            }
+            break;
+        }
+    }
+}
+
+void DumpSurfaceFormats(Printer &p, AppInstance &inst, AppSurface &surface) {
+    std::vector<VkSurfaceFormatKHR> formats;
+    if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
+        for (auto &format : surface.surf_formats2) {
+            formats.push_back(format.surfaceFormat);
+        }
+    } else {
+        for (auto &format : surface.surf_formats) {
+            formats.push_back(format);
+        }
+    }
+    ObjectWrapper obj(p, "Formats", formats.size());
+    int i = 0;
+    for (auto &format : formats) {
+        p.SetElementIndex(i++);
+        DumpVkSurfaceFormatKHR(p, "SurfaceFormat", format);
+    }
+}
+
+void DumpPresentModes(Printer &p, AppSurface &surface) {
+    ArrayWrapper arr(p, "Present Modes", surface.surf_present_modes.size());
+    for (auto &mode : surface.surf_present_modes) {
+        p.SetAsType().PrintString(VkPresentModeKHRString(mode));
+    }
+}
+
+void DumpSurfaceCapabilities(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurface &surface) {
+    auto &surf_cap = surface.surface_capabilities;
+    p.SetSubHeader().SetIgnoreMinWidthInChild();
+    DumpVkSurfaceCapabilitiesKHR(p, "VkSurfaceCapabilitiesKHR", surf_cap);
+
+    if (inst.CheckExtensionEnabled(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)) {
+        p.SetSubHeader();
+        ObjectWrapper obj(p, "VkSurfaceCapabilities2EXT");
+        DumpVkSurfaceCounterFlagsEXT(p, "supportedSurfaceCounters", surface.surface_capabilities2_ext.supportedSurfaceCounters);
+    }
+    if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
+        chain_iterator_surface_capabilities2(p, inst, gpu, surface.surface_capabilities2_khr.pNext);
+    }
+    if (inst.CheckExtensionEnabled(VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME) ||
+        inst.CheckExtensionEnabled(VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME)) {
+        const char *surf_ext_name = VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME;
+        if (!inst.CheckExtensionEnabled(VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME)) {
+            surf_ext_name = VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME;
+        }
+        p.SetSubHeader();
+        ObjectWrapper obj(p, surf_ext_name);
+        for (auto &mode : surface.surf_present_modes) {
+            VkSurfacePresentModeKHR present_mode{};
+            present_mode.sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR;
+            present_mode.presentMode = mode;
+
+            VkPhysicalDeviceSurfaceInfo2KHR surface_info{};
+            surface_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
+            surface_info.surface = surface.surface_extension.surface;
+            surface_info.pNext = &present_mode;
+
+            VkSurfacePresentModeCompatibilityKHR SurfacePresentModeCompatibilityKHR{};
+            SurfacePresentModeCompatibilityKHR.sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR;
+
+            VkSurfacePresentScalingCapabilitiesKHR SurfacePresentScalingCapabilitiesKHR{};
+            SurfacePresentScalingCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT;
+            SurfacePresentScalingCapabilitiesKHR.pNext = &SurfacePresentModeCompatibilityKHR;
+
+            VkSurfaceCapabilities2KHR surface_caps2{};
+            surface_caps2.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR;
+            surface_caps2.pNext = &SurfacePresentScalingCapabilitiesKHR;
+
+            VkResult err = vkGetPhysicalDeviceSurfaceCapabilities2KHR(gpu.phys_device, &surface_info, &surface_caps2);
+            if (err != VK_SUCCESS) {
+                continue;
+            }
+
+            std::vector<VkPresentModeKHR> compatible_present_modes{SurfacePresentModeCompatibilityKHR.presentModeCount};
+            SurfacePresentModeCompatibilityKHR.pPresentModes = compatible_present_modes.data();
+
+            err = vkGetPhysicalDeviceSurfaceCapabilities2KHR(gpu.phys_device, &surface_info, &surface_caps2);
+
+            if (err == VK_SUCCESS) {
+                ObjectWrapper present_mode_obj(p, VkPresentModeKHRString(mode));
+
+                p.PrintKeyValue("minImageCount", surface_caps2.surfaceCapabilities.minImageCount);
+                p.PrintKeyValue("maxImageCount", surface_caps2.surfaceCapabilities.maxImageCount);
+
+                DumpVkSurfacePresentScalingCapabilitiesKHR(p, "VkSurfacePresentScalingCapabilitiesKHR",
+                                                           SurfacePresentScalingCapabilitiesKHR);
+                DumpVkSurfacePresentModeCompatibilityKHR(p, "VkSurfacePresentModeCompatibilityKHR",
+                                                         SurfacePresentModeCompatibilityKHR);
+            }
+        }
+    }
+}
+
+void DumpSurface(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurface &surface, std::set<std::string> surface_types) {
+    std::string surface_type_list_str = "";
+    if (surface_types.size() > 0) {
+        surface_type_list_str = " [";
+        bool is_first = true;
+        for (auto &name : surface_types) {
+            if (!is_first) {
+                surface_type_list_str += ", ";
+            } else {
+                is_first = false;
+            }
+            surface_type_list_str += name;
+        }
+        surface_type_list_str += "]";
+    }
+    ObjectWrapper obj(p, std::string("GPU id : ") + p.DecorateAsValue(std::to_string(gpu.id)) + " (" + gpu.props.deviceName + ")" +
+                             surface_type_list_str);
+
+    if (surface_types.size() == 0) {
+        p.SetAsType().PrintKeyString("Surface type", "No type found");
+    } else if (surface_types.size() == 1) {
+        p.SetAsType().PrintKeyString("Surface type", surface.surface_extension.name);
+    } else {
+        ArrayWrapper arr(p, "Surface types", surface_types.size());
+        for (auto &name : surface_types) {
+            p.PrintString(name);
+        }
+    }
+
+    DumpSurfaceFormats(p, inst, surface);
+    DumpPresentModes(p, surface);
+    DumpSurfaceCapabilities(p, inst, gpu, surface);
+
+    p.AddNewline();
+}
+
+struct SurfaceTypeGroup {
+    AppSurface *surface;
+    AppGpu *gpu;
+    std::set<std::string> surface_types;
+};
+
+bool operator==(AppSurface const &a, AppSurface const &b) {
+    return a.phys_device == b.phys_device && a.surf_present_modes == b.surf_present_modes && a.surf_formats == b.surf_formats &&
+           a.surf_formats2 == b.surf_formats2 && a.surface_capabilities == b.surface_capabilities &&
+           a.surface_capabilities2_khr == b.surface_capabilities2_khr && a.surface_capabilities2_ext == b.surface_capabilities2_ext;
+}
+
+#if defined(VULKANINFO_WSI_ENABLED)
+void DumpPresentableSurfaces(Printer &p, AppInstance &inst, const std::vector<std::unique_ptr<AppGpu>> &gpus,
+                             const std::vector<std::unique_ptr<AppSurface>> &surfaces) {
+    // Don't print anything if no surfaces are found
+    if (surfaces.size() == 0) return;
+    p.SetHeader();
+    ObjectWrapper obj(p, "Presentable Surfaces");
+    IndentWrapper indent(p);
+
+    std::vector<SurfaceTypeGroup> surface_list;
+
+    for (auto &surface : surfaces) {
+        auto exists = surface_list.end();
+        for (auto it = surface_list.begin(); it != surface_list.end(); it++) {
+            // check for duplicate surfaces that differ only by the surface extension
+            if (*(it->surface) == *(surface.get())) {
+                exists = it;
+                break;
+            }
+        }
+        if (exists != surface_list.end()) {
+            exists->surface_types.insert(surface.get()->surface_extension.name);
+        } else {
+            // find surface.phys_device's corresponding AppGpu
+            AppGpu *corresponding_gpu = nullptr;
+            for (auto &gpu : gpus) {
+                if (gpu->phys_device == surface->phys_device) corresponding_gpu = gpu.get();
+            }
+            if (corresponding_gpu != nullptr)
+                surface_list.push_back({surface.get(), corresponding_gpu, {surface.get()->surface_extension.name}});
+        }
+    }
+    for (auto &group : surface_list) {
+        DumpSurface(p, inst, *group.gpu, *group.surface, group.surface_types);
+    }
+    p.AddNewline();
+}
+#endif  // defined(VULKANINFO_WSI_ENABLED)
+
+void DumpGroups(Printer &p, AppInstance &inst) {
+    if (inst.CheckExtensionEnabled(VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME)) {
+        auto groups = GetGroups(inst);
+        if (groups.size() == 0) {
+            p.SetHeader();
+            ObjectWrapper obj(p, "Groups");
+            p.PrintString("No Device Groups Found");
+            p.AddNewline();
+            return;
+        }
+
+        p.SetHeader();
+        ObjectWrapper obj_device_groups(p, "Device Groups");
+        IndentWrapper indent(p);
+
+        int group_id = 0;
+        for (auto &group : groups) {
+            ObjectWrapper obj_group(p, "Group " + std::to_string(group_id));
+            auto group_props = GetGroupProps(inst, group);
+            {
+                ObjectWrapper obj_properties(p, "Properties");
+                {
+                    ArrayWrapper arr(p, "physicalDevices", group.physicalDeviceCount);
+                    int id = 0;
+                    for (auto &prop : group_props) {
+                        p.PrintString(std::string(prop.deviceName) + " (ID: " + p.DecorateAsValue(std::to_string(id++)) + ")");
+                    }
+                }
+                p.PrintKeyValue("subsetAllocation", group.subsetAllocation);
+            }
+            p.AddNewline();
+
+            auto group_capabilities = GetGroupCapabilities(inst, group);
+            if (!group_capabilities) {
+                p.PrintKeyString("Present Capabilities",
+                                 "Group does not support VK_KHR_device_group, skipping printing present capabilities");
+            } else {
+                ObjectWrapper obj_caps(p, "Present Capabilities");
+                for (uint32_t i = 0; i < group.physicalDeviceCount; i++) {
+                    ObjectWrapper obj_device(
+                        p, std::string(group_props[i].deviceName) + " (ID: " + p.DecorateAsValue(std::to_string(i)) + ")");
+                    ArrayWrapper arr(p, "Can present images from the following devices", group.physicalDeviceCount);
+
+                    for (uint32_t j = 0; j < group.physicalDeviceCount; j++) {
+                        uint32_t mask = 1 << j;
+                        if (group_capabilities->presentMask[i] & mask) {
+                            p.PrintString(std::string(group_props[j].deviceName) + " (ID: " + p.DecorateAsValue(std::to_string(j)) +
+                                          ")");
+                        }
+                    }
+                }
+                DumpVkDeviceGroupPresentModeFlagsKHR(p, "Present modes", group_capabilities->modes);
+            }
+            p.AddNewline();
+            group_id++;
+        }
+        p.AddNewline();
+    }
+}
+
+void GpuDumpProps(Printer &p, AppGpu &gpu, bool show_promoted_structs) {
+    auto props = gpu.GetDeviceProperties();
+    p.SetSubHeader();
+    {
+        ObjectWrapper obj(p, "VkPhysicalDeviceProperties");
+        p.SetMinKeyWidth(17);
+        if (p.Type() == OutputType::json) {
+            p.PrintKeyValue("apiVersion", props.apiVersion);
+            p.PrintKeyValue("driverVersion", props.driverVersion);
+        } else {
+            p.SetValueDescription(std::to_string(props.apiVersion)).PrintKeyString("apiVersion", APIVersion(props.apiVersion));
+            p.SetValueDescription(std::to_string(props.driverVersion))
+                .PrintKeyString("driverVersion", gpu.GetDriverVersionString());
+        }
+        p.PrintKeyString("vendorID", to_hex_str(props.vendorID));
+        p.PrintKeyString("deviceID", to_hex_str(props.deviceID));
+        p.PrintKeyString("deviceType", VkPhysicalDeviceTypeString(props.deviceType));
+        p.PrintKeyString("deviceName", props.deviceName);
+        p.PrintKeyValue("pipelineCacheUUID", props.pipelineCacheUUID);
+    }
+    p.AddNewline();
+    DumpVkPhysicalDeviceLimits(p, "VkPhysicalDeviceLimits", gpu.props.limits);
+    p.AddNewline();
+    DumpVkPhysicalDeviceSparseProperties(p, "VkPhysicalDeviceSparseProperties", gpu.props.sparseProperties);
+    p.AddNewline();
+    if (gpu.inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        void *place = gpu.props2.pNext;
+        chain_iterator_phys_device_props2(p, gpu.inst, gpu, show_promoted_structs, place);
+    }
+}
+
+void GpuDumpQueueProps(Printer &p, AppGpu &gpu, const AppQueueFamilyProperties &queue) {
+    VkQueueFamilyProperties props = queue.props;
+    p.SetSubHeader().SetElementIndex(static_cast<int>(queue.queue_index));
+    ObjectWrapper obj_queue_props(p, "queueProperties");
+    p.SetMinKeyWidth(27);
+    if (p.Type() == OutputType::vkconfig_output) {
+        DumpVkExtent3D(p, "minImageTransferGranularity", props.minImageTransferGranularity);
+    } else {
+        p.PrintKeyValue("minImageTransferGranularity", props.minImageTransferGranularity);
+    }
+    p.PrintKeyValue("queueCount", props.queueCount);
+    p.PrintKeyString("queueFlags", VkQueueFlagsString(props.queueFlags));
+    p.PrintKeyValue("timestampValidBits", props.timestampValidBits);
+
+    if (!queue.can_present) {
+        p.PrintKeyString("present support", "false");
+    } else if (queue.can_always_present) {
+        p.PrintKeyString("present support", "true");
+    } else {
+        size_t width = 0;
+        for (const auto &support : queue.present_support) {
+            if (support.first.size() > width) width = support.first.size();
+        }
+        ObjectWrapper obj_present_support(p, "present support");
+        p.SetMinKeyWidth(width);
+        for (const auto &support : queue.present_support) {
+            p.PrintKeyString(support.first, support.second ? "true" : "false");
+        }
+    }
+    chain_iterator_queue_properties2(p, gpu, queue.pNext);
+
+    p.AddNewline();
+}
+
+// This prints a number of bytes in a human-readable format according to prefixes of the International System of Quantities (ISQ),
+// defined in ISO/IEC 80000. The prefixes used here are not SI prefixes, but rather the binary prefixes based on powers of 1024
+// (kibi-, mebi-, gibi- etc.).
+#define kBufferSize 32
+
+std::string NumToNiceStr(const size_t sz) {
+    const char prefixes[] = "KMGTPEZY";
+    char buf[kBufferSize];
+    int which = -1;
+    double result = (double)sz;
+    while (result > 1024 && which < 7) {
+        result /= 1024;
+        ++which;
+    }
+
+    char unit[] = "\0i";
+    if (which >= 0) {
+        unit[0] = prefixes[which];
+    }
+#ifdef _WIN32
+    _snprintf_s(buf, kBufferSize * sizeof(char), kBufferSize, "%.2f %sB", result, unit);
+#else
+    snprintf(buf, kBufferSize, "%.2f %sB", result, unit);
+#endif
+    return std::string(buf);
+}
+
+std::string append_human_readable(VkDeviceSize memory) {
+    return std::to_string(memory) + " (" + to_hex_str(memory) + ") (" + NumToNiceStr(static_cast<size_t>(memory)) + ")";
+}
+
+void GpuDumpMemoryProps(Printer &p, AppGpu &gpu) {
+    p.SetHeader();
+    ObjectWrapper obj_mem_props(p, "VkPhysicalDeviceMemoryProperties");
+    IndentWrapper indent(p);
+    {
+        ObjectWrapper obj_mem_heaps(p, "memoryHeaps", gpu.memory_props.memoryHeapCount);
+
+        for (uint32_t i = 0; i < gpu.memory_props.memoryHeapCount; ++i) {
+            p.SetElementIndex(static_cast<int>(i));
+            ObjectWrapper obj_mem_heap(p, "memoryHeaps");
+            p.SetMinKeyWidth(6);
+            p.PrintKeyString("size", append_human_readable(gpu.memory_props.memoryHeaps[i].size));
+            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_BUDGET_EXTENSION_NAME)) {
+                p.PrintKeyString("budget", append_human_readable(gpu.heapBudget[i]));
+                p.PrintKeyString("usage", append_human_readable(gpu.heapUsage[i]));
+            }
+            DumpVkMemoryHeapFlags(p, "flags", gpu.memory_props.memoryHeaps[i].flags);
+        }
+    }
+    {
+        ObjectWrapper obj_mem_types(p, "memoryTypes", gpu.memory_props.memoryTypeCount);
+        for (uint32_t i = 0; i < gpu.memory_props.memoryTypeCount; ++i) {
+            p.SetElementIndex(static_cast<int>(i));
+            ObjectWrapper obj_mem_type(p, "memoryTypes");
+            p.SetMinKeyWidth(13);
+            p.PrintKeyValue("heapIndex", gpu.memory_props.memoryTypes[i].heapIndex);
+
+            auto flags = gpu.memory_props.memoryTypes[i].propertyFlags;
+            DumpVkMemoryPropertyFlags(p, "propertyFlags = " + to_hex_str(flags), flags);
+
+            ObjectWrapper usable_for(p, "usable for");
+            const uint32_t memtype_bit = 1U << i;
+
+            // only linear and optimal tiling considered
+            for (auto &image_tiling : gpu.memory_image_support_types) {
+                p.SetOpenDetails();
+                ArrayWrapper arr(p, VkImageTilingString(VkImageTiling(image_tiling.tiling)));
+                bool has_any_support_types = false;
+                bool regular = false;
+                bool transient = false;
+                bool sparse = false;
+                for (auto &image_format : image_tiling.formats) {
+                    if (image_format.type_support.size() > 0) {
+                        bool has_a_support_type = false;
+                        for (auto &img_type : image_format.type_support) {
+                            if (img_type.Compatible(memtype_bit)) {
+                                has_a_support_type = true;
+                                has_any_support_types = true;
+                                if (img_type.type == ImageTypeSupport::Type::regular) regular = true;
+                                if (img_type.type == ImageTypeSupport::Type::transient) transient = true;
+                                if (img_type.type == ImageTypeSupport::Type::sparse) sparse = true;
+                            }
+                        }
+                        if (has_a_support_type) {
+                            if (image_format.format == color_format) {
+                                p.PrintString("color images");
+                            } else {
+                                p.PrintString(VkFormatString(image_format.format));
+                            }
+                        }
+                    }
+                }
+                if (!has_any_support_types) {
+                    p.PrintString("None");
+                } else {
+                    if (regular && !transient && sparse) p.PrintString("(non-transient)");
+                    if (regular && transient && !sparse) p.PrintString("(non-sparse)");
+                    if (regular && !transient && !sparse) p.PrintString("(non-sparse, non-transient)");
+                    if (!regular && transient && sparse) p.PrintString("(sparse and transient only)");
+                    if (!regular && !transient && sparse) p.PrintString("(sparse only)");
+                    if (!regular && transient && !sparse) p.PrintString("(transient only)");
+                }
+            }
+        }
+    }
+    p.AddNewline();
+}
+
+void GpuDumpFeatures(Printer &p, AppGpu &gpu, bool show_promoted_structs) {
+    p.SetHeader();
+    DumpVkPhysicalDeviceFeatures(p, "VkPhysicalDeviceFeatures", gpu.features);
+    p.AddNewline();
+    if (gpu.inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        void *place = gpu.features2.pNext;
+        chain_iterator_phys_device_features2(p, gpu, show_promoted_structs, place);
+    }
+}
+
+void GpuDumpTextFormatProperty(Printer &p, const AppGpu &gpu, PropFlags formats, const std::set<VkFormat> &format_list,
+                               uint32_t counter) {
+    p.SetElementIndex(counter);
+    ObjectWrapper obj_common_group(p, "Common Format Group");
+    IndentWrapper indent_inner(p);
+    {
+        ArrayWrapper arr_formats(p, "Formats", format_list.size());
+        for (auto &fmt : format_list) {
+            p.SetAsType().PrintString(VkFormatString(fmt));
+        }
+    }
+    ObjectWrapper obj(p, "Properties");
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME)) {
+        DumpVkFormatFeatureFlags2(p, "linearTilingFeatures", formats.props3.linearTilingFeatures);
+        DumpVkFormatFeatureFlags2(p, "optimalTilingFeatures", formats.props3.optimalTilingFeatures);
+        DumpVkFormatFeatureFlags2(p, "bufferFeatures", formats.props3.bufferFeatures);
+    } else {
+        DumpVkFormatFeatureFlags(p, "linearTilingFeatures", formats.props.linearTilingFeatures);
+        DumpVkFormatFeatureFlags(p, "optimalTilingFeatures", formats.props.optimalTilingFeatures);
+        DumpVkFormatFeatureFlags(p, "bufferFeatures", formats.props.bufferFeatures);
+    }
+    p.AddNewline();
+}
+
+void GpuDumpToolingInfo(Printer &p, AppGpu &gpu) {
+    auto tools = GetToolingInfo(gpu);
+    if (tools.size() > 0) {
+        p.SetSubHeader();
+        ObjectWrapper obj(p, "Tooling Info");
+        for (auto tool : tools) {
+            DumpVkPhysicalDeviceToolProperties(p, tool.name, tool);
+            p.AddNewline();
+        }
+    }
+}
+
+void GpuDumpCooperativeMatrix(Printer &p, AppGpu &gpu) {
+    auto props = GetCooperativeMatrixInfo(gpu);
+    if (props.size() > 0) {
+        p.SetSubHeader();
+        ObjectWrapper obj(p, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR");
+        for (const auto prop : props) {
+            DumpVkCooperativeMatrixPropertiesKHR(p, "VkCooperativeMatrixPropertiesKHR", prop);
+            p.AddNewline();
+        }
+    }
+}
+
+void GpuDumpCalibrateableTimeDomain(Printer &p, AppGpu &gpu) {
+    auto props = GetTimeDomainInfo(gpu);
+    if (props.size() > 0) {
+        p.SetSubHeader();
+        ObjectWrapper obj_mem_props(p, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR");
+        {
+            for (uint32_t i = 0; i < props.size(); ++i) {
+                p.SetElementIndex(static_cast<int>(i));
+                DumpVkTimeDomainKHR(p, "pTimeDomains", props[i]);
+                p.AddNewline();
+            }
+        }
+    }
+}
+
+void GpuDumpFragmentShadingRate(Printer &p, AppGpu &gpu) {
+    auto props = GetFragmentShadingRateInfo(gpu);
+    if (props.size() > 0) {
+        p.SetSubHeader();
+        ObjectWrapper obj(p, "vkGetPhysicalDeviceFragmentShadingRatesKHR");
+        for (const auto prop : props) {
+            DumpVkPhysicalDeviceFragmentShadingRateKHR(p, "VkPhysicalDeviceFragmentShadingRateKHR", prop);
+            p.AddNewline();
+        }
+    }
+}
+
+// VK_EXT_sample_locations ('Multisample Properties' is too ambiguous of a name)
+void GpuDumpSampleLocations(Printer &p, AppGpu &gpu) {
+    auto props = GetSampleLocationInfo(gpu);
+    if (props.size() > 0) {
+        p.SetSubHeader();
+        ObjectWrapper obj(p, "vkGetPhysicalDeviceMultisamplePropertiesEXT");
+        for (uint32_t i = 0; i < props.size(); i++) {
+            const VkSampleCountFlagBits sample_count = (VkSampleCountFlagBits)(1 << i);
+            DumpVkSampleCountFlagBits(p, "samples", sample_count);
+            DumpVkMultisamplePropertiesEXT(p, "VkMultisamplePropertiesEXT", props[i]);
+            p.AddNewline();
+        }
+    }
+}
+
+void GpuDevDump(Printer &p, AppGpu &gpu) {
+    p.SetHeader();
+    ObjectWrapper obj_format_props(p, "Format Properties");
+    IndentWrapper indent_outer(p);
+
+    if (p.Type() == OutputType::text) {
+        auto fmtPropMap = FormatPropMap(gpu);
+        int counter = 0;
+        std::set<VkFormat> unsupported_formats;
+        for (auto &prop : fmtPropMap) {
+            VkFormatProperties props = prop.first.props;
+            VkFormatProperties3 props3 = prop.first.props3;
+            if (props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0 && props.bufferFeatures == 0 &&
+                props3.linearTilingFeatures == 0 && props3.optimalTilingFeatures == 0 && props3.bufferFeatures == 0) {
+                unsupported_formats = prop.second;
+                continue;
+            }
+            GpuDumpTextFormatProperty(p, gpu, prop.first, prop.second, counter++);
+        }
+
+        ArrayWrapper arr_unsupported_formats(p, "Unsupported Formats", unsupported_formats.size());
+        for (auto &fmt : unsupported_formats) {
+            p.SetAsType().PrintString(VkFormatString(fmt));
+        }
+    } else {
+        std::set<VkFormat> formats_to_print;
+        for (auto &format_range : format_ranges) {
+            if (gpu.FormatRangeSupported(format_range)) {
+                for (int32_t fmt_counter = format_range.first_format; fmt_counter <= format_range.last_format; ++fmt_counter) {
+                    formats_to_print.insert(static_cast<VkFormat>(fmt_counter));
+                }
+            }
+        }
+        for (const auto &fmt : formats_to_print) {
+            auto formats = get_format_properties(gpu, fmt);
+            p.SetTitleAsType();
+            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME)) {
+                DumpVkFormatProperties3(p, VkFormatString(fmt), formats.props3);
+            } else {
+                DumpVkFormatProperties(p, VkFormatString(fmt), formats.props);
+            }
+        }
+    }
+
+    p.AddNewline();
+}
+
+void DumpVkVideoProfileInfoKHRCustom(Printer &p, std::string name, const VkVideoProfileInfoKHR &obj) {
+    // We use custom dumping here because we do not want to output ignored fields
+    // e.g. for monochrome chromaBitDepth is ignored
+    ObjectWrapper object{p, name};
+    DumpVkVideoCodecOperationFlagBitsKHR(p, "videoCodecOperation", obj.videoCodecOperation);
+    DumpVkVideoChromaSubsamplingFlagsKHR(p, "chromaSubsampling", obj.chromaSubsampling);
+    DumpVkVideoComponentBitDepthFlagsKHR(p, "lumaBitDepth", obj.lumaBitDepth);
+    if (obj.chromaSubsampling != VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR) {
+        DumpVkVideoComponentBitDepthFlagsKHR(p, "chromaBitDepth", obj.chromaBitDepth);
+    } else {
+        DumpVkVideoComponentBitDepthFlagsKHR(p, "chromaBitDepth", 0);
+    }
+}
+
+void GpuDumpVideoProfiles(Printer &p, AppGpu &gpu, bool show_video_props) {
+    p.SetHeader();
+    ObjectWrapper video_profiles_obj(p, "Video Profiles", gpu.video_profiles.size());
+    IndentWrapper indent_outer(p);
+
+    if (p.Type() != OutputType::text || show_video_props) {
+        // Video profile details per profile
+        for (const auto &video_profile : gpu.video_profiles) {
+            p.SetSubHeader();
+            ObjectWrapper video_profile_obj(p, video_profile->name);
+            IndentWrapper indent_inner(p);
+            {
+                p.SetSubHeader();
+                ObjectWrapper profile_info_obj(p, "Video Profile Definition");
+                p.SetSubHeader();
+                DumpVkVideoProfileInfoKHRCustom(p, "VkVideoProfileInfoKHR", video_profile->profile_info);
+                chain_iterator_video_profile_info(p, gpu, video_profile->profile_info.pNext);
+            }
+            {
+                p.SetSubHeader();
+                ObjectWrapper capabilities_obj(p, "Video Profile Capabilities");
+                p.SetSubHeader();
+                DumpVkVideoCapabilitiesKHR(p, "VkVideoCapabilitiesKHR", video_profile->capabilities);
+                chain_iterator_video_capabilities(p, gpu, video_profile->capabilities.pNext);
+            }
+            {
+                p.SetSubHeader();
+                ObjectWrapper video_formats_obj(p, "Video Formats");
+                for (const auto &video_formats_it : video_profile->formats_by_category) {
+                    const auto &video_format_category_name = video_formats_it.first;
+                    const auto &video_format_props = video_formats_it.second;
+                    ObjectWrapper video_format_category(p, video_format_category_name, video_format_props.size());
+                    for (size_t i = 0; i < video_format_props.size(); ++i) {
+                        ObjectWrapper video_format_obj(p, video_format_category_name + " Format #" + std::to_string(i + 1));
+                        p.SetSubHeader();
+                        DumpVkVideoFormatPropertiesKHR(p, "VkVideoFormatPropertiesKHR", video_format_props[i]);
+                        chain_iterator_video_format_properties(p, gpu, video_format_props[i].pNext);
+                    }
+                }
+            }
+
+            p.AddNewline();
+        }
+    } else {
+        // Video profile list only
+        for (const auto &video_profile : gpu.video_profiles) {
+            p.PrintString(video_profile->name);
+        }
+    }
+
+    p.AddNewline();
+}
+
+AppDisplayPlane::AppDisplayPlane(AppGpu &gpu, uint32_t index, const VkDisplayPlanePropertiesKHR &in_prop)
+    : global_index(index), properties(in_prop) {
+    std::ostringstream display_name;
+
+    supported_displays = GetVector<VkDisplayKHR>("vkGetDisplayPlaneSupportedDisplaysKHR", vkGetDisplayPlaneSupportedDisplaysKHR,
+                                                 gpu.phys_device, global_index);
+}
+
+std::vector<AppDisplayPlane> enumerate_display_planes(AppGpu &gpu) {
+    std::vector<AppDisplayPlane> result;
+    if (vkGetPhysicalDeviceDisplayPlanePropertiesKHR) {
+        auto planes = GetVector<VkDisplayPlanePropertiesKHR>("vkGetPhysicalDeviceDisplayPlanePropertiesKHR",
+                vkGetPhysicalDeviceDisplayPlanePropertiesKHR, gpu.phys_device);
+        for (uint32_t i = 0; i < planes.size(); i++) {
+            result.emplace_back(gpu, i, planes[i]);
+        }
+    }
+    return result;
+}
+
+AppDisplayMode::AppDisplayMode(AppGpu &gpu, const VkDisplayModePropertiesKHR &in_properties,
+                               const std::set<uint32_t> &supported_planes)
+    : properties(in_properties) {
+    for (auto plane : supported_planes) {
+        VkDisplayPlaneCapabilitiesKHR cap;
+
+        vkGetDisplayPlaneCapabilitiesKHR(gpu.phys_device, properties.displayMode, plane, &cap);
+        capabilities[plane] = cap;
+    }
+}
+
+static std::string MakeName(uint32_t index, const VkDisplayPropertiesKHR &prop) {
+    std::stringstream name;
+    name << "Display id : " << index << " (" << prop.displayName << ")";
+    return name.str();
+}
+
+AppDisplay::AppDisplay(AppGpu &gpu, uint32_t index, const VkDisplayPropertiesKHR &in_properties,
+                       const std::vector<AppDisplayPlane> &all_planes)
+    : global_index(index), name(MakeName(index, in_properties)), properties(in_properties) {
+    auto mode_props = GetVector<VkDisplayModePropertiesKHR>("vkGetDisplayModePropertiesKHR", vkGetDisplayModePropertiesKHR,
+                                                            gpu.phys_device, properties.display);
+
+    std::set<uint32_t> supported_planes;
+    for (const auto &plane : all_planes) {
+        for (const auto &display : plane.supported_displays) {
+            if (display == properties.display) {
+                supported_planes.insert(plane.global_index);
+            }
+        }
+    }
+
+    for (const auto &prop : mode_props) {
+        modes.emplace_back(gpu, prop, supported_planes);
+    }
+}
+
+std::vector<AppDisplay> enumerate_displays(AppGpu &gpu, const std::vector<AppDisplayPlane> &all_planes) {
+    std::vector<AppDisplay> result;
+
+    if (vkGetPhysicalDeviceDisplayPropertiesKHR) {
+        auto properties = GetVector<VkDisplayPropertiesKHR>("vkGetPhysicalDeviceDisplayPropertiesKHR",
+                vkGetPhysicalDeviceDisplayPropertiesKHR, gpu.phys_device);
+
+        for (uint32_t i = 0; i < properties.size(); i++) {
+            result.emplace_back(gpu, i, properties[i], all_planes);
+        }
+    }
+    return result;
+}
+
+void GpuDumpDisplays(Printer &p, AppGpu &gpu) {
+    if (gpu.displays.size() == 0) {
+        return;
+    }
+
+    p.SetHeader();
+    ObjectWrapper display_props_obj(p, "Display Properties", gpu.displays.size());
+
+    for (const auto &display : gpu.displays) {
+        p.SetSubHeader();
+        ObjectWrapper display_obj(p, display.name);
+
+        DumpVkDisplayPropertiesKHR(p, "VkDisplayPropertiesKHR", display.properties);
+        ArrayWrapper arr(p, "Display Modes", display.modes.size());
+
+        for (uint32_t m = 0; m < display.modes.size(); m++) {
+            const auto &mode = display.modes[m];
+            std::ostringstream mode_name;
+            mode_name << "Display Mode : " << p.DecorateAsValue(std::to_string(m)) << " ("
+                      << mode.properties.parameters.visibleRegion.width << " x " << mode.properties.parameters.visibleRegion.height
+                      << ")";
+
+            ObjectWrapper mode_obj(p, mode_name.str());
+
+            DumpVkDisplayModeParametersKHR(p, "VkDisplayModeParametersKHR", mode.properties.parameters);
+
+            ArrayWrapper cap_arr(p, "Display Plane Capabilities", mode.capabilities.size());
+            for (const auto &cap : mode.capabilities) {
+                std::ostringstream cap_name;
+                cap_name << "Capabilities (Plane " << p.DecorateAsValue(std::to_string(cap.first)) << ")";
+
+                ObjectWrapper cap_obj(p, cap_name.str());
+
+                DumpVkDisplayPlaneCapabilitiesKHR(p, "VkDisplayPlaneCapabilitiesKHR", cap.second);
+            }
+        }
+    }
+}
+
+void GpuDumpDisplayPlanes(Printer &p, AppGpu &gpu) {
+    if (gpu.display_planes.size() == 0) {
+        return;
+    }
+
+    p.SetHeader();
+    ObjectWrapper display_props_obj(p, "Display Plane Properties", gpu.display_planes.size());
+
+    for (const auto &plane : gpu.display_planes) {
+        p.SetSubHeader();
+        ObjectWrapper display_obj(p, std::string("Display Plane id : ") + p.DecorateAsValue(std::to_string(plane.global_index)));
+
+        auto *current = gpu.FindDisplay(plane.properties.currentDisplay);
+
+        p.PrintKeyString("currentDisplay", current ? current->name.c_str() : "none");
+
+        DumpVkDisplayPlanePropertiesKHR(p, "VkDisplayPlanePropertiesKHR", plane.properties);
+
+        ArrayWrapper arr(p, "Supported Displays", plane.supported_displays.size());
+        for (auto handle : plane.supported_displays) {
+            auto *display = gpu.FindDisplay(handle);
+            p.SetAsType().PrintString(display ? display->name.c_str() : "UNKNOWN");
+        }
+    }
+}
+
+struct ShowSettings {
+    bool all = false;
+    bool tool_props = false;
+    bool formats = false;
+    bool promoted_structs = false;
+    bool video_props = false;
+};
+
+// Print gpu info for text, html, & vkconfig_output
+// Uses a separate function than schema-json for clarity
+void DumpGpu(Printer &p, AppGpu &gpu, const ShowSettings &show) {
+    ObjectWrapper obj_gpu(p, "GPU" + std::to_string(gpu.id));
+    IndentWrapper indent(p);
+
+    GpuDumpProps(p, gpu, show.promoted_structs);
+    DumpExtensions(p, "Device Extensions", gpu.device_extensions);
+    p.AddNewline();
+    {
+        p.SetHeader();
+        ObjectWrapper obj_family_props(p, "VkQueueFamilyProperties");
+        for (const auto &queue_prop : gpu.extended_queue_props) {
+            GpuDumpQueueProps(p, gpu, queue_prop);
+        }
+    }
+    GpuDumpMemoryProps(p, gpu);
+    GpuDumpFeatures(p, gpu, show.promoted_structs);
+    if (show.tool_props) {
+        GpuDumpToolingInfo(p, gpu);
+    }
+
+    if (show.all) {
+        GpuDumpCooperativeMatrix(p, gpu);
+        GpuDumpCalibrateableTimeDomain(p, gpu);
+        GpuDumpFragmentShadingRate(p, gpu);
+        GpuDumpSampleLocations(p, gpu);
+    }
+
+    if (p.Type() != OutputType::text || show.formats) {
+        GpuDevDump(p, gpu);
+    }
+
+    if (!gpu.video_profiles.empty()) {
+        GpuDumpVideoProfiles(p, gpu, show.video_props);
+    }
+
+    if (!gpu.displays.empty()) {
+        GpuDumpDisplays(p, gpu);
+    }
+
+    if (!gpu.display_planes.empty()) {
+        GpuDumpDisplayPlanes(p, gpu);
+    }
+
+    p.AddNewline();
+}
+
+// Print capabilities section of profiles schema
+void DumpGpuProfileCapabilities(Printer &p, AppGpu &gpu, bool show_promoted_structs) {
+    ObjectWrapper capabilities(p, "capabilities");
+    {
+        ObjectWrapper temp_name_obj(p, "device");
+        DumpExtensions(p, "extensions", gpu.device_extensions);
+        {
+            ObjectWrapper obj(p, "features");
+            GpuDumpFeatures(p, gpu, show_promoted_structs);
+        }
+        {
+            ObjectWrapper obj(p, "properties");
+            {
+                ObjectWrapper props_obj(p, "VkPhysicalDeviceProperties");
+                auto props = gpu.GetDeviceProperties();
+                p.PrintKeyValue("apiVersion", props.apiVersion);
+                p.PrintKeyValue("deviceID", props.deviceID);
+                p.PrintKeyString("deviceName", props.deviceName);
+                p.PrintKeyString("deviceType", std::string("VK_") + VkPhysicalDeviceTypeString(props.deviceType));
+                p.PrintKeyValue("driverVersion", props.driverVersion);
+
+                DumpVkPhysicalDeviceLimits(p, "VkPhysicalDeviceLimits", gpu.props.limits);
+                {
+                    ArrayWrapper arr(p, "pipelineCacheUUID");
+                    for (const auto &uuid : props.pipelineCacheUUID) p.PrintElement(static_cast<uint32_t>(uuid));
+                }
+                DumpVkPhysicalDeviceSparseProperties(p, "VkPhysicalDeviceSparseProperties", gpu.props.sparseProperties);
+                p.PrintKeyValue("vendorID", props.vendorID);
+            }
+            if (gpu.inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+                void *place = gpu.props2.pNext;
+                chain_iterator_phys_device_props2(p, gpu.inst, gpu, show_promoted_structs, place);
+            }
+        }
+        {
+            ObjectWrapper obj(p, "formats");
+            std::set<VkFormat> already_printed_formats;
+            for (const auto &format : format_ranges) {
+                if (gpu.FormatRangeSupported(format)) {
+                    for (int32_t fmt_counter = format.first_format; fmt_counter <= format.last_format; ++fmt_counter) {
+                        VkFormat fmt = static_cast<VkFormat>(fmt_counter);
+                        if (already_printed_formats.count(fmt) > 0) {
+                            continue;
+                        }
+                        auto formats = get_format_properties(gpu, fmt);
+
+                        // don't print format properties that are unsupported
+                        if (formats.props.linearTilingFeatures == 0 && formats.props.optimalTilingFeatures == 0 &&
+                            formats.props.bufferFeatures == 0 && formats.props3.linearTilingFeatures == 0 &&
+                            formats.props3.optimalTilingFeatures == 0 && formats.props3.bufferFeatures == 0)
+                            continue;
+
+                        ObjectWrapper format_obj(p, std::string("VK_") + VkFormatString(fmt));
+                        {
+                            // Want to explicitly list VkFormatProperties in addition to VkFormatProperties3 if available
+                            DumpVkFormatProperties(p, "VkFormatProperties", formats.props);
+                            VkFormatProperties2 format_props2{};
+                            format_props2.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
+                            format_props2.formatProperties = formats.props;
+                            std::unique_ptr<format_properties2_chain> chain_for_format_props2;
+                            setup_format_properties2_chain(format_props2, chain_for_format_props2, gpu);
+                            vkGetPhysicalDeviceFormatProperties2KHR(gpu.phys_device, fmt, &format_props2);
+                            chain_iterator_format_properties2(p, gpu, format_props2.pNext);
+                        }
+                        already_printed_formats.insert(fmt);
+                    }
+                }
+            }
+        }
+        {
+            ArrayWrapper arr(p, "queueFamiliesProperties");
+            for (const auto &extended_queue_prop : gpu.extended_queue_props) {
+                ObjectWrapper queue_obj(p, "");
+                {
+                    ObjectWrapper obj_queue_props(p, "VkQueueFamilyProperties");
+                    VkQueueFamilyProperties props = extended_queue_prop.props;
+                    DumpVkExtent3D(p, "minImageTransferGranularity", props.minImageTransferGranularity);
+                    p.PrintKeyValue("queueCount", props.queueCount);
+                    DumpVkQueueFlags(p, "queueFlags", props.queueFlags);
+                    p.PrintKeyValue("timestampValidBits", props.timestampValidBits);
+                }
+                chain_iterator_queue_properties2(p, gpu, extended_queue_prop.pNext);
+            }
+        }
+        if (!gpu.video_profiles.empty()) {
+            ArrayWrapper video_profiles(p, "videoProfiles");
+            for (const auto &video_profile : gpu.video_profiles) {
+                ObjectWrapper video_profile_obj(p, "");
+                {
+                    ObjectWrapper profile_info_obj(p, "profile");
+                    DumpVkVideoProfileInfoKHRCustom(p, "VkVideoProfileInfoKHR", video_profile->profile_info);
+                    chain_iterator_video_profile_info(p, gpu, video_profile->profile_info.pNext);
+                }
+                {
+                    ObjectWrapper capabilities_obj(p, "capabilities");
+                    DumpVkVideoCapabilitiesKHR(p, "VkVideoCapabilitiesKHR", video_profile->capabilities);
+                    chain_iterator_video_capabilities(p, gpu, video_profile->capabilities.pNext);
+                }
+                {
+                    ArrayWrapper video_formats(p, "formats");
+                    for (const auto &video_format : video_profile->formats) {
+                        ObjectWrapper video_format_obj(p, "");
+                        DumpVkVideoFormatPropertiesKHR(p, "VkVideoFormatPropertiesKHR", video_format.properties);
+                        chain_iterator_video_format_properties(p, gpu, video_format.properties.pNext);
+                    }
+                }
+            }
+        }
+    }
+#if defined(VK_ENABLE_BETA_EXTENSIONS)
+    // Print portability subset extension, features, and properties if available
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME) &&
+        (gpu.inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) ||
+         gpu.inst.api_version >= VK_API_VERSION_1_1)) {
+        ObjectWrapper macos_obj(p, "macos-specific");
+        {
+            ObjectWrapper ext_obj(p, "extensions");
+            const std::string portability_ext_name = VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME;
+            for (const auto &ext : gpu.device_extensions) {
+                if (portability_ext_name == ext.extensionName) {
+                    p.PrintExtension(ext.extensionName, ext.specVersion);
+                }
+            }
+        }
+        {
+            ObjectWrapper features_obj(p, "features");
+            void *feats_place = gpu.features2.pNext;
+            while (feats_place) {
+                VkBaseOutStructure *structure = static_cast<VkBaseOutStructure *>(feats_place);
+                if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR) {
+                    auto *features = reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(structure);
+                    DumpVkPhysicalDevicePortabilitySubsetFeaturesKHR(p, "VkPhysicalDevicePortabilitySubsetFeaturesKHR", *features);
+                    break;
+                }
+                feats_place = structure->pNext;
+            }
+        }
+        {
+            ObjectWrapper property_obj(p, "properties");
+            void *props_place = gpu.props2.pNext;
+            while (props_place) {
+                VkBaseOutStructure *structure = static_cast<VkBaseOutStructure *>(props_place);
+                if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR) {
+                    auto *props = reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR *>(structure);
+                    DumpVkPhysicalDevicePortabilitySubsetPropertiesKHR(p, "VkPhysicalDevicePortabilitySubsetPropertiesKHR", *props);
+                    break;
+                }
+                props_place = structure->pNext;
+            }
+        }
+    }
+#endif  // defined(VK_ENABLE_BETA_EXTENSIONS)
+}
+void PrintProfileBaseInfo(Printer &p, const std::string &device_name, uint32_t apiVersion, const std::string &device_label,
+                          const std::vector<std::string> &capabilities) {
+    ObjectWrapper vk_info(p, device_name);
+    p.PrintKeyValue("version", 1);
+    p.PrintKeyString("api-version", APIVersion(apiVersion).str());
+    p.PrintKeyString("label", device_label);
+    p.PrintKeyString("description", std::string("Exported from ") + APP_SHORT_NAME);
+    {
+        ObjectWrapper contributors(p, "contributors");
+    }
+    {
+        ArrayWrapper contributors(p, "history");
+        ObjectWrapper element(p, "");
+        p.PrintKeyValue("revision", 1);
+        std::time_t t = std::time(0);  // get time now
+        std::tm *now = std::localtime(&t);
+        std::string date =
+            std::to_string(now->tm_year + 1900) + '-' + std::to_string(now->tm_mon + 1) + '-' + std::to_string(now->tm_mday);
+        p.PrintKeyString("date", date);
+        p.PrintKeyString("author", std::string("Automated export from ") + APP_SHORT_NAME);
+        p.PrintKeyString("comment", "");
+    }
+    ArrayWrapper contributors(p, "capabilities");
+    for (const auto &str : capabilities) p.PrintString(str);
+}
+
+// Prints profiles section of profiles schema
+void DumpGpuProfileInfo(Printer &p, AppGpu &gpu) {
+    ObjectWrapper profiles(p, "profiles");
+
+    std::string device_label = std::string(gpu.props.deviceName) + " driver " + gpu.GetDriverVersionString();
+    std::string device_name =
+        std::string("VP_" APP_UPPER_CASE_NAME "_") + std::string(gpu.props.deviceName) + "_" + gpu.GetDriverVersionString();
+    ;
+    for (auto &c : device_name) {
+        if (c == ' ' || c == '.') c = '_';
+    }
+    PrintProfileBaseInfo(p, device_name, gpu.props.apiVersion, device_label, {"device"});
+#if defined(VK_ENABLE_BETA_EXTENSIONS)
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME) &&
+        (gpu.inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) ||
+         gpu.inst.api_version >= VK_API_VERSION_1_1)) {
+        PrintProfileBaseInfo(p, device_name + "_portability_subset", gpu.props.apiVersion, device_label + " subset",
+                             {"device", "macos-specific"});
+    }
+#endif  // defined(VK_ENABLE_BETA_EXTENSIONS)
+}
+
+// Print summary of system
+void DumpSummaryInstance(Printer &p, AppInstance &inst) {
+    p.SetSubHeader();
+    DumpExtensions(p, "Instance Extensions", inst.global_extensions, true);
+    p.AddNewline();
+
+    p.SetSubHeader();
+    ArrayWrapper arr(p, "Instance Layers", inst.global_layers.size());
+    IndentWrapper indent(p);
+    std::sort(inst.global_layers.begin(), inst.global_layers.end(), [](LayerExtensionList &left, LayerExtensionList &right) -> int {
+        return std::strncmp(left.layer_properties.layerName, right.layer_properties.layerName, VK_MAX_DESCRIPTION_SIZE) < 0;
+    });
+    size_t layer_name_max = 0;
+    size_t layer_desc_max = 0;
+    size_t layer_version_max = 0;
+
+    // find max of each type to align everything in columns
+    for (auto &layer : inst.global_layers) {
+        auto props = layer.layer_properties;
+        layer_name_max = std::max(layer_name_max, strlen(props.layerName));
+        layer_desc_max = std::max(layer_desc_max, strlen(props.description));
+        layer_version_max = std::max(layer_version_max, APIVersion(layer.layer_properties.specVersion).str().size());
+    }
+    for (auto &layer : inst.global_layers) {
+        auto v_str = APIVersion(layer.layer_properties.specVersion).str();
+        auto props = layer.layer_properties;
+
+        auto name_padding = std::string(layer_name_max - strlen(props.layerName), ' ');
+        auto desc_padding = std::string(layer_desc_max - strlen(props.description), ' ');
+        auto version_padding = std::string(layer_version_max - v_str.size(), ' ');
+        p.PrintString(std::string(props.layerName) + name_padding + " " + props.description + desc_padding + " " + v_str + " " +
+                      version_padding + " version " + std::to_string(props.implementationVersion));
+    }
+    p.AddNewline();
+}
+
+void DumpSummaryGPU(Printer &p, AppGpu &gpu) {
+    ObjectWrapper obj(p, "GPU" + std::to_string(gpu.id));
+    p.SetMinKeyWidth(18);
+    auto props = gpu.GetDeviceProperties();
+    p.PrintKeyValue("apiVersion", APIVersion(props.apiVersion));
+    if (gpu.found_driver_props) {
+        p.PrintKeyString("driverVersion", gpu.GetDriverVersionString());
+    } else {
+        p.PrintKeyValue("driverVersion", props.driverVersion);
+    }
+    p.PrintKeyString("vendorID", to_hex_str(props.vendorID));
+    p.PrintKeyString("deviceID", to_hex_str(props.deviceID));
+    p.PrintKeyString("deviceType", VkPhysicalDeviceTypeString(props.deviceType));
+    p.PrintKeyString("deviceName", props.deviceName);
+
+    if (gpu.found_driver_props) {
+        DumpVkDriverId(p, "driverID", gpu.driverID);
+        p.PrintKeyString("driverName", gpu.driverName);
+        p.PrintKeyString("driverInfo", gpu.driverInfo);
+        p.PrintKeyValue("conformanceVersion", gpu.conformanceVersion);
+    }
+    if (gpu.found_device_id_props) {
+        p.PrintKeyValue("deviceUUID", gpu.deviceUUID);
+        p.PrintKeyValue("driverUUID", gpu.driverUUID);
+    }
+}
+
+// ============ Printing Logic ============= //
+
+#ifdef _WIN32
+// Enlarges the console window to have a large scrollback size.
+static void ConsoleEnlarge() {
+    const HANDLE console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
+
+    // make the console window bigger
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    COORD buffer_size;
+    if (GetConsoleScreenBufferInfo(console_handle, &csbi)) {
+        buffer_size.X = csbi.dwSize.X + 30;
+        buffer_size.Y = 20000;
+        SetConsoleScreenBufferSize(console_handle, buffer_size);
+    }
+
+    SMALL_RECT r;
+    r.Left = r.Top = 0;
+    r.Right = csbi.dwSize.X - 1 + 30;
+    r.Bottom = 50;
+    SetConsoleWindowInfo(console_handle, true, &r);
+
+    // change the console window title
+    SetConsoleTitle(TEXT(APP_SHORT_NAME));
+}
+#endif
+
+// Global configuration
+enum class OutputCategory { text, html, profile_json, vkconfig_output, summary };
+const char *help_message_body =
+    "OPTIONS:\n"
+    "[-h, --help]         Print this help.\n"
+    "[--summary]          Show a summary of the instance and GPU's on a system.\n"
+    "[-o <filename>, --output <filename>]\n"
+    "                     Print output to a new file whose name is specified by filename.\n"
+    "                     File will be written to the current working directory.\n"
+    "[--text]             Produce a text version of " APP_SHORT_NAME
+    " output to stdout. This is\n"
+    "                     the default output.\n"
+    "[--html]             Produce an html version of " APP_SHORT_NAME
+    " output, saved as\n"
+    "                     \"" APP_SHORT_NAME
+    ".html\" in the directory in which the command\n"
+    "                     is run.\n"
+    "[-j, --json]         Produce a json version of " APP_SHORT_NAME
+    " output conforming to the Vulkan\n"
+    "                     Profiles schema, saved as \n"
+    "                     \"VP_" APP_UPPER_CASE_NAME
+    "_[DEVICE_NAME]_[DRIVER_VERSION].json\"\n"
+    "                     of the first gpu in the system.\n"
+    "[-j=<gpu-number>, --json=<gpu-number>]\n"
+    "                     For a multi-gpu system, a single gpu can be targeted by\n"
+    "                     specifying the gpu-number associated with the gpu of \n"
+    "                     interest. This number can be determined by running\n"
+    "                     " APP_SHORT_NAME
+    " without any options specified.\n"
+    "[--show-all]         Show everything (includes all the below options)\n"
+    "[--show-tool-props]  Show the active VkPhysicalDeviceToolPropertiesEXT that " APP_SHORT_NAME
+    " finds.\n"
+    "[--show-formats]     Display the format properties of each physical device.\n"
+    "                     Note: This only affects text output.\n"
+    "[--show-promoted-structs] Include structs promoted to core in pNext Chains.\n"
+    "[--show-video-props]\n"
+    "                     Display the video profile info, video capabilities and\n"
+    "                     video format properties of each video profile supported\n"
+    "                     by each physical device.\n"
+    "                     Note: This only affects text output which by default\n"
+    "                     only contains the list of supported video profile names.\n";
+
+void print_usage(const std::string &executable_name) {
+    std::cout << "\n" APP_SHORT_NAME " - Summarize " API_NAME " information in relation to the current environment.\n\n";
+    std::cout << "USAGE: \n";
+    std::cout << "    " << executable_name << " --summary\n";
+    std::cout << "    " << executable_name << " -o <filename> | --output <filename>\n";
+    std::cout << "    " << executable_name << " -j | -j=<gpu-number> | --json | --json=<gpu-number>\n";
+    std::cout << "    " << executable_name << " --text\n";
+    std::cout << "    " << executable_name << " --html\n";
+    std::cout << "    " << executable_name << " --show-all\n";
+    std::cout << "    " << executable_name << " --show-formats\n";
+    std::cout << "    " << executable_name << " --show-tool-props\n";
+    std::cout << "    " << executable_name << " --show-promoted-structs\n";
+    std::cout << "    " << executable_name << " --show-video-props\n";
+    std::cout << "\n" << help_message_body << std::endl;
+}
+
+struct ParsedResults {
+    OutputCategory output_category = OutputCategory::text;
+    uint32_t selected_gpu = 0;
+    bool has_selected_gpu = false;  // differentiate between selecting the 0th gpu and using the default 0th value
+    ShowSettings show;
+    bool print_to_file = false;
+    std::string filename;  // set if explicitly given, or if vkconfig_output has a <path> argument
+    std::string default_filename;
+};
+
+util::vulkaninfo_optional<ParsedResults> parse_arguments(int argc, char **argv, std::string executable_name) {
+    ParsedResults results{};
+    results.default_filename = APP_SHORT_NAME ".txt";
+    for (int i = 1; i < argc; ++i) {
+        // A internal-use-only format for communication with the Vulkan Configurator tool
+        // Usage "--vkconfig_output <path>"
+        // -o can be used to specify the filename instead
+        if (0 == strcmp("--vkconfig_output", argv[i])) {
+            results.output_category = OutputCategory::vkconfig_output;
+            results.print_to_file = true;
+            results.default_filename = APP_SHORT_NAME ".json";
+            if (argc > (i + 1) && argv[i + 1][0] != '-') {
+#ifdef WIN32
+                results.filename = (std::string(argv[i + 1]) + "\\" APP_SHORT_NAME ".json");
+#else
+                results.filename = (std::string(argv[i + 1]) + "/" APP_SHORT_NAME ".json");
+#endif
+                ++i;
+            }
+        } else if (strncmp("--json", argv[i], 6) == 0 || strncmp(argv[i], "-j", 2) == 0) {
+            if (strlen(argv[i]) > 7 && strncmp("--json=", argv[i], 7) == 0) {
+                results.selected_gpu = static_cast<uint32_t>(strtol(argv[i] + 7, nullptr, 10));
+                results.has_selected_gpu = true;
+            }
+            if (strlen(argv[i]) > 3 && strncmp("-j=", argv[i], 3) == 0) {
+                results.selected_gpu = static_cast<uint32_t>(strtol(argv[i] + 3, nullptr, 10));
+                results.has_selected_gpu = true;
+            }
+            results.output_category = OutputCategory::profile_json;
+            results.default_filename = APP_SHORT_NAME ".json";
+            results.print_to_file = true;
+        } else if (strcmp(argv[i], "--summary") == 0) {
+            results.output_category = OutputCategory::summary;
+        } else if (strcmp(argv[i], "--text") == 0) {
+            results.output_category = OutputCategory::text;
+            results.default_filename = APP_SHORT_NAME ".txt";
+        } else if (strcmp(argv[i], "--html") == 0) {
+            results.output_category = OutputCategory::html;
+            results.print_to_file = true;
+            results.default_filename = APP_SHORT_NAME ".html";
+        } else if (strcmp(argv[i], "--show-all") == 0) {
+            results.show.all = true;
+            results.show.tool_props = true;
+            results.show.formats = true;
+            results.show.promoted_structs = true;
+            results.show.video_props = true;
+        } else if (strcmp(argv[i], "--show-tool-props") == 0) {
+            results.show.tool_props = true;
+        } else if (strcmp(argv[i], "--show-formats") == 0) {
+            results.show.formats = true;
+        } else if (strcmp(argv[i], "--show-promoted-structs") == 0) {
+            results.show.promoted_structs = true;
+        } else if (strcmp(argv[i], "--show-video-props") == 0) {
+            results.show.video_props = true;
+        } else if ((strcmp(argv[i], "--output") == 0 || strcmp(argv[i], "-o") == 0) && argc > (i + 1)) {
+            if (argv[i + 1][0] == '-') {
+                std::cout << "-o or --output must be followed by a filename\n";
+                return {};
+            }
+            results.print_to_file = true;
+            results.filename = argv[i + 1];
+            ++i;
+        } else if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) {
+            print_usage(executable_name);
+            return {};
+        } else {
+            print_usage(executable_name);
+            return {};
+        }
+    }
+    return results;
+}
+
+PrinterCreateDetails get_printer_create_details(ParsedResults &parse_data, AppInstance &inst, AppGpu &selected_gpu,
+                                                std::string const &executable_name) {
+    PrinterCreateDetails create{};
+    create.print_to_file = parse_data.print_to_file;
+    create.file_name = (!parse_data.filename.empty()) ? parse_data.filename : parse_data.default_filename;
+    switch (parse_data.output_category) {
+        default:
+        case (OutputCategory::text):
+            create.output_type = OutputType::text;
+            break;
+        case (OutputCategory::html):
+            create.output_type = OutputType::html;
+            break;
+        case (OutputCategory::profile_json):
+            create.output_type = OutputType::json;
+            create.start_string =
+                std::string("{\n\t\"$schema\": ") + "\"https://schema.khronos.org/vulkan/profiles-0.8-latest.json\"";
+            if (parse_data.filename.empty()) {
+                create.file_name = std::string("VP_" APP_UPPER_CASE_NAME "_") + std::string(selected_gpu.props.deviceName) + "_" +
+                                   selected_gpu.GetDriverVersionString();
+                for (auto &c : create.file_name) {
+                    if (c == ' ' || c == '.') c = '_';
+                }
+                create.file_name += ".json";
+            }
+            break;
+        case (OutputCategory::vkconfig_output):
+            create.output_type = OutputType::vkconfig_output;
+            create.start_string = "{\n\t\"" API_NAME " Instance Version\": \"" + inst.api_version.str() + "\"";
+            break;
+    }
+    return create;
+}
+
+void RunPrinter(Printer &p, ParsedResults parse_data, AppInstance &instance, std::vector<std::unique_ptr<AppGpu>> &gpus,
+                std::vector<std::unique_ptr<AppSurface>> &surfaces) {
+#ifdef VK_USE_PLATFORM_IOS_MVK
+    p.SetAlwaysOpenDetails(true);
+#endif
+    if (parse_data.output_category == OutputCategory::summary) {
+        DumpSummaryInstance(p, instance);
+        p.SetHeader();
+        ObjectWrapper obj(p, "Devices");
+        IndentWrapper indent(p);
+        for (auto &gpu : gpus) {
+            DumpSummaryGPU(p, *(gpu.get()));
+        }
+    } else if (parse_data.output_category == OutputCategory::profile_json) {
+        DumpGpuProfileCapabilities(p, *(gpus.at(parse_data.selected_gpu).get()), parse_data.show.promoted_structs);
+        DumpGpuProfileInfo(p, *(gpus.at(parse_data.selected_gpu).get()));
+    } else {
+        // text, html, vkconfig_output
+        p.SetHeader();
+        DumpExtensions(p, "Instance Extensions", instance.global_extensions);
+        p.AddNewline();
+
+        DumpLayers(p, instance.global_layers, gpus);
+#if defined(VULKANINFO_WSI_ENABLED)
+        // Doesn't print anything if no surfaces are available
+        DumpPresentableSurfaces(p, instance, gpus, surfaces);
+#endif  // defined(VULKANINFO_WSI_ENABLED)
+        DumpGroups(p, instance);
+
+        p.SetHeader();
+        ObjectWrapper obj(p, "Device Properties and Extensions");
+        IndentWrapper indent(p);
+
+        for (auto &gpu : gpus) {
+            DumpGpu(p, *(gpu.get()), parse_data.show);
+        }
+    }
+}
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+// On iOS, we'll call this ourselves from a parent routine in the GUI
+int vulkanInfoMain(int argc, char **argv) {
+#else
+int main(int argc, char **argv) {
+#endif
+
+    // Figure out the name of the executable, pull out the name if given a path
+    // Default is `vulkaninfo`
+    std::string executable_name = APP_SHORT_NAME;
+    if (argc >= 1) {
+        const auto argv_0 = std::string(argv[0]);
+        // don't include path separator
+        // Look for forward slash first, only look for backslash if that found nothing
+        auto last_occurrence = argv_0.rfind('/');
+        if (last_occurrence == std::string::npos) {
+            last_occurrence = argv_0.rfind('\\');
+        }
+        if (last_occurrence != std::string::npos && last_occurrence + 1 < argv_0.size()) {
+            executable_name = argv_0.substr(last_occurrence + 1);
+        }
+    }
+
+    auto parsing_return = parse_arguments(argc, argv, executable_name);
+    if (!parsing_return) return 1;
+    ParsedResults parse_data = parsing_return.value();
+
+#if defined(_MSC_VER)
+    _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
+    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
+    _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
+    _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
+
+    if (ConsoleIsExclusive()) ConsoleEnlarge();
+    User32Handles local_user32_handles;
+    user32_handles = &local_user32_handles;
+    if (!local_user32_handles.load()) {
+        fprintf(stderr, "Failed to load user32.dll library!\n");
+        if (parse_data.output_category == OutputCategory::text && !parse_data.print_to_file) wait_for_console_destroy();
+        return 1;
+    }
+#endif
+
+    int return_code = 0;  // set in case of error
+    std::unique_ptr<Printer> printer;
+    std::ostream std_out(std::cout.rdbuf());
+    std::ofstream file_out;
+    std::ostream *out = &std_out;
+
+    // if any essential vulkan call fails, it throws an exception
+    try {
+        AppInstance instance = {};
+        SetupWindowExtensions(instance);
+
+        auto phys_devices = instance.FindPhysicalDevices();
+
+#if defined(VULKANINFO_WSI_ENABLED)
+        for (auto &surface_extension : instance.surface_extensions) {
+            surface_extension.create_window(instance);
+            surface_extension.surface = surface_extension.create_surface(instance);
+        }
+#endif  // defined(VULKANINFO_WSI_ENABLED)
+
+        std::vector<std::unique_ptr<AppGpu>> gpus;
+
+        uint32_t gpu_counter = 0;
+        for (auto &phys_device : phys_devices) {
+            gpus.push_back(
+                std::unique_ptr<AppGpu>(new AppGpu(instance, gpu_counter++, phys_device, parse_data.show.promoted_structs)));
+        }
+
+        std::vector<std::unique_ptr<AppSurface>> surfaces;
+#if defined(VULKANINFO_WSI_ENABLED)
+        for (auto &surface_extension : instance.surface_extensions) {
+            for (auto &gpu : gpus) {
+                try {
+                    // check if the surface is supported by the physical device before adding it to the list
+                    VkBool32 supported = VK_FALSE;
+                    VkResult err = vkGetPhysicalDeviceSurfaceSupportKHR(gpu->phys_device, 0, surface_extension.surface, &supported);
+                    if (err != VK_SUCCESS || supported == VK_FALSE) continue;
+
+                    surfaces.push_back(
+                        std::unique_ptr<AppSurface>(new AppSurface(instance, *gpu.get(), gpu->phys_device, surface_extension)));
+                } catch (std::exception &e) {
+                    std::cerr << "ERROR while creating surface for extension " << surface_extension.name << " : " << e.what()
+                              << "\n";
+                }
+            }
+        }
+#endif  // defined(VULKANINFO_WSI_ENABLED)
+
+        if (parse_data.selected_gpu >= gpus.size()) {
+            if (parse_data.has_selected_gpu) {
+                std::cout << "The selected gpu (" << parse_data.selected_gpu << ") is not a valid GPU index. ";
+                if (gpus.size() == 0) {
+                    std::cout << APP_SHORT_NAME " could not find any GPU's.\n";
+                    return 1;
+                } else {
+                    if (gpus.size() == 1) {
+                        std::cout << "The only available GPU selection is 0.\n";
+                    } else {
+                        std::cout << "The available GPUs are in the range of 0 to " << gpus.size() - 1 << ".\n";
+                    }
+                    return 1;
+                }
+            } else if (parse_data.output_category == OutputCategory::profile_json) {
+                std::cout << APP_SHORT_NAME " could not find any GPU's.\n";
+            }
+        }
+
+        auto printer_data = get_printer_create_details(parse_data, instance, *gpus.at(parse_data.selected_gpu), executable_name);
+        if (printer_data.print_to_file) {
+            file_out = std::ofstream(printer_data.file_name);
+            out = &file_out;
+        }
+        printer = std::unique_ptr<Printer>(new Printer(printer_data, *out, instance.api_version));
+
+        RunPrinter(*(printer.get()), parse_data, instance, gpus, surfaces);
+
+        // Call the printer's destructor before the file handle gets closed
+        printer.reset(nullptr);
+#if defined(VULKANINFO_WSI_ENABLED)
+        for (auto &surface_extension : instance.surface_extensions) {
+            AppDestroySurface(instance, surface_extension.surface);
+            surface_extension.destroy_window(instance);
+        }
+#endif  // defined(VULKANINFO_WSI_ENABLED)
+    } catch (std::exception &e) {
+        // Print the error to stderr and leave all outputs in a valid state (mainly for json)
+        std::cerr << "ERROR at " << e.what() << "\n";
+        if (printer) {
+            printer->FinishOutput();
+        }
+        return_code = 1;
+
+        // Call the printer's destructor before the file handle gets closed
+        printer.reset(nullptr);
+    }
+
+#ifdef _WIN32
+    if (parse_data.output_category == OutputCategory::text && !parse_data.print_to_file) wait_for_console_destroy();
+#endif
+
+    return return_code;
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.h b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.h
new file mode 100644
index 00000000..e15583e6
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.h
@@ -0,0 +1,2035 @@
+/*
+ * Copyright (c) 2015-2026 The Khronos Group Inc.
+ * Copyright (c) 2015-2026 Valve Corporation
+ * Copyright (c) 2015-2026 LunarG, Inc.
+ * Copyright (c) 2023-2024 RasterGrid Kft.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
+ * Author: David Pinedo <david@lunarg.com>
+ * Author: Mark Lobodzinski <mark@lunarg.com>
+ * Author: Rene Lindsay <rene@lunarg.com>
+ * Author: Jeremy Kniager <jeremyk@lunarg.com>
+ * Author: Shannon McPherson <shannon@lunarg.com>
+ * Author: Bob Ellison <bob@lunarg.com>
+ * Author: Charles Giessen <charles@lunarg.com>
+ *
+ */
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <exception>
+#include <iostream>
+#include <fstream>
+#include <map>
+#include <memory>
+#include <ostream>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <set>
+#include <vector>
+#include <utility>
+#include <functional>
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <cstring>
+
+#ifdef __GNUC__
+#ifndef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200809L
+#endif
+#else
+#define strndup(p, n) strdup(p)
+#endif
+
+#if defined(_WIN32)
+#include <fcntl.h>
+#include <io.h>
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#if _MSC_VER == 1900
+#pragma warning(disable : 4800)
+#endif
+#endif  // _WIN32
+
+#if defined(VK_USE_PLATFORM_XLIB_KHR) || defined(VK_USE_PLATFORM_XCB_KHR)
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#endif
+
+#if defined(VK_USE_PLATFORM_MACOS_MVK) || defined(VK_USE_PLATFORM_METAL_EXT)
+#include "metal_view.h"
+#endif
+
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+#include <wayland-client.h>
+#endif
+
+#include "vulkaninfo_functions.h"
+
+#include <vulkan/vulkan.h>
+
+static std::string VkResultString(VkResult err);
+
+// General error: Get file + line and a short message
+struct FileLineException : std::runtime_error {
+    FileLineException(const std::string &arg, const char *file, int line) : runtime_error(arg) {
+        msg = std::string(file) + ":" + std::to_string(line) + ": " + arg;
+    }
+    ~FileLineException() throw() {}
+    const char *what() const throw() { return msg.c_str(); }
+
+  private:
+    std::string msg;
+};
+#define THROW_ERR(arg) throw FileLineException(arg, __FILE__, __LINE__);
+
+// Vulkan function error: Get name of function, file, line, and the error code returned by the function
+struct VulkanException : std::runtime_error {
+    VulkanException(const std::string &function, const char *file, int line, VkResult err) : runtime_error(function) {
+        msg = std::string(file) + ":" + std::to_string(line) + ":" + function + " failed with " + VkResultString(err);
+    }
+    ~VulkanException() throw() {}
+    const char *what() const throw() { return msg.c_str(); }
+
+  private:
+    std::string msg;
+};
+#define THROW_VK_ERR(func_name, err) throw VulkanException(func_name, __FILE__, __LINE__, err);
+
+#ifdef _WIN32
+
+#define strdup _strdup
+
+// Returns nonzero if the console is used only for this process. Will return
+// zero if another process (such as cmd.exe) is also attached.
+static int ConsoleIsExclusive(void) {
+    DWORD pids[2];
+    DWORD num_pids = GetConsoleProcessList(pids, ARRAYSIZE(pids));
+    return num_pids <= 1;
+}
+void wait_for_console_destroy() {
+    if (ConsoleIsExclusive()) Sleep(INFINITE);
+}
+
+// User32 function declarations
+using PFN_AdjustWindowRect = WINUSERAPI BOOL(WINAPI *)(_Inout_ LPRECT, _In_ DWORD, _In_ BOOL);
+using PFN_CreateWindowExA = WINUSERAPI HWND(WINAPI *)(_In_ DWORD, _In_opt_ LPCSTR, _In_opt_ LPCSTR, _In_ DWORD, _In_ int, _In_ int,
+                                                      _In_ int, _In_ int, _In_opt_ HWND, _In_opt_ HMENU, _In_opt_ HINSTANCE,
+                                                      _In_opt_ LPVOID);
+using PFN_DefWindowProcA = WINUSERAPI LRESULT(WINAPI *)(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM);
+using PFN_DestroyWindow = WINUSERAPI BOOL(WINAPI *)(_In_ HWND);
+using PFN_LoadIconA = WINUSERAPI HICON(WINAPI *)(_In_opt_ HINSTANCE, _In_ LPCSTR);
+using PFN_RegisterClassExA = WINUSERAPI ATOM(WINAPI *)(_In_ CONST WNDCLASSEXA *);
+
+struct User32Handles {
+    // User32 dll handle
+    HMODULE user32DllHandle = nullptr;
+
+    // User32 function pointers
+    PFN_AdjustWindowRect pfnAdjustWindowRect = nullptr;
+    PFN_CreateWindowExA pfnCreateWindowExA = nullptr;
+    PFN_DefWindowProcA pfnDefWindowProcA = nullptr;
+    PFN_DestroyWindow pfnDestroyWindow = nullptr;
+    PFN_LoadIconA pfnLoadIconA = nullptr;
+    PFN_RegisterClassExA pfnRegisterClassExA = nullptr;
+
+    User32Handles() noexcept {}
+    ~User32Handles() noexcept {
+        if (user32DllHandle != nullptr) {
+            FreeLibrary(user32DllHandle);
+        }
+    }
+    // Don't allow moving of this class
+    User32Handles(User32Handles const &) = delete;
+    User32Handles &operator=(User32Handles const &) = delete;
+    User32Handles(User32Handles &&) = delete;
+    User32Handles &operator=(User32Handles &&) = delete;
+
+    bool load() {
+        user32DllHandle = LoadLibraryExA("user32.dll", nullptr, 0);
+        if (user32DllHandle == nullptr) return false;
+        if (!load_function(pfnAdjustWindowRect, "AdjustWindowRect")) return false;
+        if (!load_function(pfnCreateWindowExA, "CreateWindowExA")) return false;
+        if (!load_function(pfnDefWindowProcA, "DefWindowProcA")) return false;
+        if (!load_function(pfnDestroyWindow, "DestroyWindow")) return false;
+        if (!load_function(pfnLoadIconA, "LoadIconA")) return false;
+        if (!load_function(pfnRegisterClassExA, "RegisterClassExA")) return false;
+        return true;
+    }
+
+  private:
+    template <typename T>
+    bool load_function(T &function_pointer, const char *function_name) {
+        function_pointer = reinterpret_cast<T>(GetProcAddress(user32DllHandle, function_name));
+        if (function_pointer == nullptr) {
+            fprintf(stderr, "Failed to load function: %s\n", function_name);
+            return false;
+        }
+        return true;
+    }
+};
+
+// Global user handles function used in windows callback and code
+User32Handles *user32_handles;
+#endif  // _WIN32
+
+#define APP_SHORT_NAME "vulkaninfo"
+#define APP_UPPER_CASE_NAME "VULKANINFO"
+#define API_NAME "Vulkan"
+
+std::vector<const char *> get_c_str_array(std::vector<std::string> const &vec) {
+    std::vector<const char *> ret;
+    for (auto &str : vec) ret.push_back(str.c_str());
+    return ret;
+}
+
+static const char *VkDebugReportFlagsEXTString(const VkDebugReportFlagsEXT flags) {
+    switch (flags) {
+        case VK_DEBUG_REPORT_ERROR_BIT_EXT:
+            return "ERROR";
+        case VK_DEBUG_REPORT_WARNING_BIT_EXT:
+            return "WARNING";
+        case VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT:
+            return "PERF";
+        case VK_DEBUG_REPORT_INFORMATION_BIT_EXT:
+            return "INFO";
+        case VK_DEBUG_REPORT_DEBUG_BIT_EXT:
+            return "DEBUG";
+        default:
+            return "UNKNOWN";
+    }
+}
+static VKAPI_ATTR VkBool32 VKAPI_CALL DbgCallback(VkDebugReportFlagsEXT msgFlags, VkDebugReportObjectTypeEXT objType,
+                                                  uint64_t srcObject, size_t location, int32_t msgCode, const char *pLayerPrefix,
+                                                  const char *pMsg, void *pUserData) {
+    std::cerr << VkDebugReportFlagsEXTString(msgFlags) << ": [" << pLayerPrefix << "] Code " << msgCode << " : " << pMsg << "\n";
+
+    // True is reserved for layer developers, and MAY mean calls are not distributed down the layer chain after validation
+    // error. False SHOULD always be returned by apps:
+    return VK_FALSE;
+}
+
+// Helper for robustly executing the two-call pattern
+template <typename T, typename F, typename... Ts>
+auto GetVectorInit(const char *func_name, F &&f, T init, Ts &&...ts) -> std::vector<T> {
+    uint32_t count = 32;  // Preallocate enough so that most calls only happen once
+    std::vector<T> results;
+    VkResult err;
+    uint32_t iteration_count = 0;
+    uint32_t max_iterations = 5;
+    do {
+        count *= 2;
+        results.resize(count, init);
+        err = f(ts..., &count, results.data());
+        results.resize(count);
+        iteration_count++;
+    } while (err == VK_INCOMPLETE && iteration_count < max_iterations);
+    if (err) THROW_VK_ERR(func_name, err);
+    return results;
+}
+
+template <typename T, typename F, typename... Ts>
+auto GetVector(const char *func_name, F &&f, Ts &&...ts) -> std::vector<T> {
+    return GetVectorInit(func_name, f, T(), ts...);
+}
+
+// Forward declarations for pNext chains
+struct phys_device_props2_chain;
+struct phys_device_mem_props2_chain;
+struct phys_device_features2_chain;
+struct surface_capabilities2_chain;
+struct format_properties2_chain;
+struct queue_properties2_chain;
+struct video_profile_info_chain;
+struct video_capabilities_chain;
+struct video_format_properties_chain;
+struct AppInstance;
+struct AppGpu;
+struct AppVideoProfile;
+struct AppDisplay;
+struct AppDisplayMode;
+struct AppDisplayPlane;
+
+void setup_phys_device_props2_chain(VkPhysicalDeviceProperties2 &start, std::unique_ptr<phys_device_props2_chain> &chain,
+                                    AppInstance &inst, AppGpu &gpu, bool show_promoted_structs);
+void setup_phys_device_mem_props2_chain(VkPhysicalDeviceMemoryProperties2 &start,
+                                        std::unique_ptr<phys_device_mem_props2_chain> &chain, AppGpu &gpu);
+void setup_phys_device_features2_chain(VkPhysicalDeviceFeatures2 &start, std::unique_ptr<phys_device_features2_chain> &chain,
+                                       AppGpu &gpu, bool show_promoted_structs);
+void setup_surface_capabilities2_chain(VkSurfaceCapabilities2KHR &start, std::unique_ptr<surface_capabilities2_chain> &chain,
+                                       AppInstance &inst, AppGpu &gpu);
+void setup_format_properties2_chain(VkFormatProperties2 &start, std::unique_ptr<format_properties2_chain> &chain, AppGpu &gpu);
+void setup_queue_properties2_chain(VkQueueFamilyProperties2 &start, std::unique_ptr<queue_properties2_chain> &chain, AppGpu &gpu);
+
+bool prepare_phys_device_props2_twocall_chain_vectors(std::unique_ptr<phys_device_props2_chain> &chain);
+
+bool is_video_format_same(const VkVideoFormatPropertiesKHR &format_a, const VkVideoFormatPropertiesKHR &format_b);
+std::vector<std::unique_ptr<AppVideoProfile>> enumerate_supported_video_profiles(AppGpu &gpu);
+
+std::vector<AppDisplayPlane> enumerate_display_planes(AppGpu &gpu);
+std::vector<AppDisplay> enumerate_displays(AppGpu &gpu, const std::vector<AppDisplayPlane> &all_planes);
+
+/* An ptional contains either a value or nothing. The optional asserts if a value is trying to be gotten but none exist.
+ * The interface is taken from C++17's <optional> with many aspects removed.
+ * This class assumes the template type is 'trivial'
+ */
+namespace util {
+template <typename T>
+struct vulkaninfo_optional {
+    using value_type = T;
+
+    bool _contains_value = false;
+    value_type _value;
+
+    vulkaninfo_optional() noexcept : _contains_value(false), _value({}) {}
+    vulkaninfo_optional(T value) noexcept : _contains_value(true), _value(value) {}
+
+    explicit operator bool() const noexcept { return _contains_value; }
+    bool has_value() const noexcept { return _contains_value; }
+
+    value_type value() const noexcept {
+        assert(_contains_value);
+        return _value;
+    }
+    // clang-format off
+    const value_type* operator->() const { assert(_contains_value); return _value;}
+    value_type* operator->() { assert(_contains_value); return &_value;}
+    const value_type& operator*() const& { assert(_contains_value); return _value;}
+    value_type& operator*() & { assert(_contains_value); return _value;}
+    const value_type&& operator*() const&& { assert(_contains_value); return _value;}
+    value_type&& operator*() && { assert(_contains_value); return _value;}
+    // clang-format on
+};  // namespace util
+}  // namespace util
+struct LayerExtensionList {
+    VkLayerProperties layer_properties;
+    std::vector<VkExtensionProperties> extension_properties;
+};
+
+struct AppInstance;
+
+struct SurfaceExtension {
+    std::string name;
+    void (*create_window)(AppInstance &) = nullptr;
+    VkSurfaceKHR (*create_surface)(AppInstance &) = nullptr;
+    void (*destroy_window)(AppInstance &) = nullptr;
+    VkSurfaceKHR surface = VK_NULL_HANDLE;
+
+    bool operator==(const SurfaceExtension &other) { return name == other.name && surface == other.surface; }
+};
+
+struct AppVideoProfile {
+    bool supported;
+
+    std::string name;
+
+    VkVideoProfileInfoKHR profile_info;
+    std::unique_ptr<video_profile_info_chain> profile_info_chain;
+
+    VkVideoCapabilitiesKHR capabilities;
+    std::unique_ptr<video_capabilities_chain> capabilities_chain;
+
+    struct Format {
+        VkVideoFormatPropertiesKHR properties;
+        std::unique_ptr<video_format_properties_chain> properties_chain;
+    };
+    std::vector<Format> formats;
+    std::unordered_map<std::string, std::vector<VkVideoFormatPropertiesKHR>> formats_by_category;
+
+    using CreateProfileInfoChainCb = std::function<std::unique_ptr<video_profile_info_chain>(const void **)>;
+    using CreateCapabilitiesChainCb = std::function<std::unique_ptr<video_capabilities_chain>(void **)>;
+    struct CreateFormatPropertiesChainCb {
+        std::string format_name;
+        VkImageUsageFlags image_usage_flags;
+        std::function<bool(const VkVideoCapabilitiesKHR &capabilities)> check_required_caps;
+        std::function<std::unique_ptr<video_format_properties_chain>(void **)> callback;
+    };
+    using CreateFormatPropertiesChainCbList = std::vector<CreateFormatPropertiesChainCb>;
+    using InitProfileCb = std::function<void(AppVideoProfile &)>;
+
+    AppVideoProfile(AppGpu &gpu, VkPhysicalDevice phys_device, const std::string &in_name,
+                    const VkVideoProfileInfoKHR &in_profile_info, CreateProfileInfoChainCb create_profile_info_chain,
+                    CreateCapabilitiesChainCb create_capabilities_chain,
+                    const CreateFormatPropertiesChainCbList &create_format_properties_chain_list, InitProfileCb init_profile)
+        : supported(true), name(in_name), profile_info(in_profile_info), capabilities({}) {
+        profile_info_chain = create_profile_info_chain(&profile_info.pNext);
+        if (profile_info_chain == nullptr) {
+            supported = false;
+            return;
+        }
+
+        capabilities.sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
+        capabilities.pNext = nullptr;
+        capabilities_chain = create_capabilities_chain(&capabilities.pNext);
+        if (capabilities_chain == nullptr) {
+            supported = false;
+            return;
+        }
+
+        init_profile(*this);
+
+        VkResult result = vkGetPhysicalDeviceVideoCapabilitiesKHR(phys_device, &profile_info, &capabilities);
+        if (result != VK_SUCCESS) {
+            supported = false;
+            return;
+        }
+
+        VkVideoProfileListInfoKHR profile_list = {VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR, nullptr, 1, &profile_info};
+
+        std::vector<VkVideoFormatPropertiesKHR> video_format_props{};
+        std::vector<std::unique_ptr<video_format_properties_chain>> video_format_props_chains{};
+        for (const auto &create_format_properties_chain_info : create_format_properties_chain_list) {
+            if (!create_format_properties_chain_info.check_required_caps(capabilities)) {
+                continue;
+            }
+
+            VkPhysicalDeviceVideoFormatInfoKHR video_format_info = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
+                                                                    &profile_list,
+                                                                    create_format_properties_chain_info.image_usage_flags};
+
+            uint32_t video_format_property_count = 0;
+            result =
+                vkGetPhysicalDeviceVideoFormatPropertiesKHR(phys_device, &video_format_info, &video_format_property_count, nullptr);
+            if (result != VK_SUCCESS) {
+                continue;
+            }
+
+            video_format_props.resize(video_format_property_count);
+            video_format_props_chains.resize(video_format_property_count);
+
+            for (uint32_t i = 0; i < video_format_property_count; ++i) {
+                video_format_props[i].sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR;
+                video_format_props_chains[i] = create_format_properties_chain_info.callback(&video_format_props[i].pNext);
+            }
+
+            result = vkGetPhysicalDeviceVideoFormatPropertiesKHR(phys_device, &video_format_info, &video_format_property_count,
+                                                                 video_format_props.data());
+            if (result == VK_SUCCESS) {
+                for (uint32_t i = 0; i < video_format_property_count; ++i) {
+                    const VkVideoFormatPropertiesKHR *existing_format = nullptr;
+                    for (const auto &format : formats) {
+                        if (is_video_format_same(format.properties, video_format_props[i])) {
+                            existing_format = &format.properties;
+                            break;
+                        }
+                    }
+                    if (existing_format == nullptr) {
+                        formats.push_back(Format{video_format_props[i], std::move(video_format_props_chains[i])});
+                        formats_by_category[create_format_properties_chain_info.format_name].push_back(video_format_props[i]);
+                    } else {
+                        formats_by_category[create_format_properties_chain_info.format_name].push_back(*existing_format);
+                    }
+                }
+            }
+
+            video_format_props.clear();
+            video_format_props_chains.clear();
+        }
+    }
+};
+
+struct AppDisplayPlane {
+    uint32_t global_index;
+    std::string name;
+    VkDisplayPlanePropertiesKHR properties;
+    std::vector<VkDisplayKHR> supported_displays;
+
+    AppDisplayPlane(AppGpu &gpu, uint32_t index, const VkDisplayPlanePropertiesKHR &in_prop);
+};
+
+struct AppDisplayMode {
+    VkDisplayModePropertiesKHR properties;
+
+    // key is a AppDisplayPlane::global_index value
+    std::map<uint32_t, VkDisplayPlaneCapabilitiesKHR> capabilities;
+
+    AppDisplayMode(AppGpu &gpu, const VkDisplayModePropertiesKHR &in_prop, const std::set<uint32_t> &supported_planes);
+};
+
+struct AppDisplay {
+    uint32_t global_index;
+
+    std::string name;
+
+    VkDisplayPropertiesKHR properties;
+    std::vector<AppDisplayMode> modes;
+
+    AppDisplay(AppGpu &gpu, uint32_t index, const VkDisplayPropertiesKHR &in_properties,
+               const std::vector<AppDisplayPlane> &all_planes);
+};
+
+class APIVersion {
+  public:
+    APIVersion() : api_version_(VK_API_VERSION_1_0) {}
+    APIVersion(uint32_t api_version) : api_version_(api_version) {}
+    void SetPatch(uint32_t patch) { api_version_ = api_version_ - Patch() + VK_API_VERSION_PATCH(patch); }
+    uint32_t Major() const { return VK_API_VERSION_MAJOR(api_version_); }
+    uint32_t Minor() const { return VK_API_VERSION_MINOR(api_version_); }
+    uint32_t Patch() const { return VK_API_VERSION_PATCH(api_version_); }
+    bool operator<(APIVersion api_version) const { return api_version_ < api_version.api_version_; }
+    bool operator<=(APIVersion api_version) const { return api_version_ <= api_version.api_version_; }
+    bool operator>(APIVersion api_version) const { return api_version_ > api_version.api_version_; }
+    bool operator>=(APIVersion api_version) const { return api_version_ >= api_version.api_version_; }
+    bool operator==(APIVersion api_version) const { return api_version_ == api_version.api_version_; }
+    bool operator!=(APIVersion api_version) const { return api_version_ != api_version.api_version_; }
+    std::string str() { return std::to_string(Major()) + "." + std::to_string(Minor()) + "." + std::to_string(Patch()); }
+    operator std::string() { return str(); }
+
+  private:
+    uint32_t api_version_;
+};
+
+std::ostream &operator<<(std::ostream &out, const APIVersion &v) {
+    return out << v.Major() << "." << v.Minor() << "." << v.Patch();
+}
+
+struct AppInstance {
+    VkInstance instance;
+    APIVersion api_version;
+
+    VkDebugReportCallbackEXT debug_callback = VK_NULL_HANDLE;
+
+    std::vector<LayerExtensionList> global_layers;
+
+    std::vector<VkExtensionProperties> global_extensions;  // Instance Extensions
+
+    std::vector<std::string> inst_extensions;
+
+    std::vector<SurfaceExtension> surface_extensions;
+
+    int width = 256, height = 256;
+
+    VkSurfaceCapabilitiesKHR surface_capabilities;
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    HINSTANCE h_instance;  // Windows Instance
+    HWND h_wnd;            // window handle
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    xcb_connection_t *xcb_connection;
+    xcb_screen_t *xcb_screen;
+    xcb_window_t xcb_window;
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    Display *xlib_display;
+    Window xlib_window;
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+    void *macos_window;
+#endif
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    void *metal_window;
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    wl_display *wayland_display;
+    wl_surface *wayland_surface;
+#endif
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    IDirectFB *dfb;
+    IDirectFBSurface *directfb_surface;
+#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR  // TODO
+    ANativeWindow *window;
+#endif
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    struct _screen_context *context;
+    struct _screen_window *window;
+#endif
+    AppInstance() {
+        VkResult dllErr = load_vulkan_library();
+
+        if (dllErr != VK_SUCCESS) {
+            THROW_ERR("Failed to initialize: " API_NAME " loader is not installed, not found, or failed to load.");
+        }
+
+        uint32_t instance_version = VK_API_VERSION_1_0;
+        if (vkEnumerateInstanceVersion) {
+            const VkResult err = vkEnumerateInstanceVersion(&instance_version);
+            if (err) THROW_VK_ERR("vkEnumerateInstanceVersion", err);
+        }
+
+        api_version = APIVersion(instance_version);
+        // fallback to baked header version if loader returns 0 for the patch version
+        if (api_version.Patch() == 0) api_version.SetPatch(VK_HEADER_VERSION);
+
+        AppGetInstanceExtensions();
+
+        const VkDebugReportCallbackCreateInfoEXT dbg_info = {VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, nullptr,
+                                                             VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT,
+                                                             DbgCallback};
+
+        const VkApplicationInfo app_info = {
+            VK_STRUCTURE_TYPE_APPLICATION_INFO, nullptr, APP_SHORT_NAME, 1, nullptr, 0, instance_version};
+
+        AppCompileInstanceExtensionsToEnable();
+
+        std::vector<const char *> inst_exts;
+        for (const auto &ext : inst_extensions) {
+            inst_exts.push_back(ext.c_str());
+        }
+
+        const VkInstanceCreateInfo inst_info = {
+            VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+            &dbg_info,
+            (CheckExtensionEnabled(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)
+                 ? static_cast<VkInstanceCreateFlags>(VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR)
+                 : 0),
+            &app_info,
+            0,
+            nullptr,
+            static_cast<uint32_t>(inst_exts.size()),
+            inst_exts.data()};
+
+        VkResult err = vkCreateInstance(&inst_info, nullptr, &instance);
+        if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
+            std::cerr << "Cannot create " API_NAME " instance.\n";
+            std::cerr << "This problem is often caused by a faulty installation of the " API_NAME
+                         " driver or attempting to use a GPU "
+                         "that does not support " API_NAME ".\n";
+            THROW_VK_ERR("vkCreateInstance", err);
+        } else if (err) {
+            THROW_VK_ERR("vkCreateInstance", err);
+        }
+
+        load_vulkan_instance_functions(instance);
+
+        err = vkCreateDebugReportCallbackEXT(instance, &dbg_info, nullptr, &debug_callback);
+        if (err != VK_SUCCESS) {
+            THROW_VK_ERR("vkCreateDebugReportCallbackEXT", err);
+        }
+    }
+
+    ~AppInstance() {
+        if (debug_callback) vkDestroyDebugReportCallbackEXT(instance, debug_callback, nullptr);
+        if (vkDestroyInstance) vkDestroyInstance(instance, nullptr);
+        unload_vulkan_library();
+    }
+
+    AppInstance(const AppInstance &) = delete;
+    const AppInstance &operator=(const AppInstance &) = delete;
+
+    bool CheckExtensionEnabled(std::string extension_to_check) const {
+        return std::any_of(inst_extensions.begin(), inst_extensions.end(),
+                           [extension_to_check](std::string str) { return str == extension_to_check; });
+    }
+
+    /* Gets a list of layer and instance extensions */
+    void AppGetInstanceExtensions() {
+        /* Scan layers */
+        auto global_layer_properties =
+            GetVector<VkLayerProperties>("vkEnumerateInstanceLayerProperties", vkEnumerateInstanceLayerProperties);
+
+        for (const auto &layer : global_layer_properties) {
+            global_layers.push_back(LayerExtensionList{layer, AppGetGlobalLayerExtensions(layer.layerName)});
+        }
+
+        // Collect global extensions
+        // Gets instance extensions, if no layer was specified in the first paramteter
+        global_extensions = AppGetGlobalLayerExtensions(nullptr);
+    }
+    void AppCompileInstanceExtensionsToEnable() {
+#if defined(VK_USE_PLATFORM_MACOS_MVK) || defined(VK_USE_PLATFORM_IOS_MVK)
+        bool metal_surface_available = false;
+        for (const auto &ext : global_extensions) {
+            if (strcmp("VK_EXT_metal_surface", ext.extensionName) == 0) {
+                metal_surface_available = true;
+            }
+        }
+#endif
+
+        for (const auto &ext : global_extensions) {
+            if (strcmp(VK_EXT_DEBUG_REPORT_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+            if (strcmp(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+            if (strcmp(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+            if (strcmp(VK_KHR_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+            if (strcmp(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+            if (strcmp(VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_IOS_MVK
+            if (strcmp(VK_MVK_IOS_SURFACE_EXTENSION_NAME, ext.extensionName) == 0 && !metal_surface_available) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+            if (strcmp(VK_MVK_MACOS_SURFACE_EXTENSION_NAME, ext.extensionName) == 0 && !metal_surface_available) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_METAL_EXT
+            if (strcmp(VK_EXT_METAL_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_VI_NN
+            if (strcmp(VK_NN_VI_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+            if (strcmp(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+            if (strcmp(VK_KHR_WIN32_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+            if (strcmp(VK_KHR_XCB_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+            if (strcmp(VK_KHR_XLIB_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+            if (strcmp(VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_GGP
+            if (strcmp(VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+            if (strcmp(VK_QNX_SCREEN_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_DISPLAY
+            if (strcmp(VK_KHR_DISPLAY_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+            if (strcmp(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+            if (strcmp(VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+            if (strcmp(VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+            if (strcmp(VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+        }
+    }
+
+    void AddSurfaceExtension(SurfaceExtension ext) { surface_extensions.push_back(ext); }
+
+    std::vector<VkExtensionProperties> AppGetGlobalLayerExtensions(const char *layer_name) {
+        return GetVector<VkExtensionProperties>("vkEnumerateInstanceExtensionProperties", vkEnumerateInstanceExtensionProperties,
+                                                layer_name);
+    }
+
+    std::vector<VkPhysicalDevice> FindPhysicalDevices() {
+        return GetVector<VkPhysicalDevice>("vkEnumeratePhysicalDevices", vkEnumeratePhysicalDevices, instance);
+    }
+
+    std::vector<VkExtensionProperties> AppGetPhysicalDeviceLayerExtensions(VkPhysicalDevice phys_device, const char *layer_name) {
+        return GetVector<VkExtensionProperties>("vkEnumerateDeviceExtensionProperties", vkEnumerateDeviceExtensionProperties,
+                                                phys_device, layer_name);
+    }
+};
+
+// --------- Platform Specific Presentation Calls --------- //
+
+#if defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR) || defined(VK_USE_PLATFORM_WIN32_KHR) ||      \
+    defined(VK_USE_PLATFORM_MACOS_MVK) || defined(VK_USE_PLATFORM_METAL_EXT) || defined(VK_USE_PLATFORM_WAYLAND_KHR) || \
+    defined(VK_USE_PLATFORM_DIRECTFB_EXT) || defined(VK_USE_PLATFORM_GGP) || defined(VK_USE_PLATFORM_SCREEN_QNX) ||     \
+    defined(VK_USE_PLATFORM_DISPLAY)
+
+#define VULKANINFO_WSI_ENABLED
+#endif
+
+//-----------------------------------------------------------
+#if defined(VULKANINFO_WSI_ENABLED)
+static void AppDestroySurface(AppInstance &inst, VkSurfaceKHR surface) {  // same for all platforms
+    vkDestroySurfaceKHR(inst.instance, surface, nullptr);
+}
+#endif  // defined(VULKANINFO_WSI_ENABLED)
+//-----------------------------------------------------------
+
+//---------------------------Win32---------------------------
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+// MS-Windows event handling function:
+LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+    return user32_handles->pfnDefWindowProcA(hWnd, uMsg, wParam, lParam);
+}
+
+static void AppCreateWin32Window(AppInstance &inst) {
+    inst.h_instance = GetModuleHandle(nullptr);
+
+    WNDCLASSEX win_class;
+
+    // Initialize the window class structure:
+    win_class.cbSize = sizeof(WNDCLASSEX);
+    win_class.style = CS_HREDRAW | CS_VREDRAW;
+    win_class.lpfnWndProc = WndProc;
+    win_class.cbClsExtra = 0;
+    win_class.cbWndExtra = 0;
+    win_class.hInstance = inst.h_instance;
+    win_class.hIcon = user32_handles->pfnLoadIconA(nullptr, IDI_APPLICATION);
+    win_class.hCursor = LoadCursor(nullptr, IDC_ARROW);
+    win_class.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
+    win_class.lpszMenuName = nullptr;
+    win_class.lpszClassName = APP_SHORT_NAME;
+    win_class.hInstance = inst.h_instance;
+    win_class.hIconSm = user32_handles->pfnLoadIconA(nullptr, IDI_WINLOGO);
+    // Register window class:
+    if (!user32_handles->pfnRegisterClassExA(&win_class)) {
+        // It didn't work, so try to give a useful error:
+        THROW_ERR("Failed to register the window class!");
+    }
+    // Create window with the registered class:
+    RECT wr = {0, 0, inst.width, inst.height};
+    user32_handles->pfnAdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
+    inst.h_wnd = user32_handles->pfnCreateWindowExA(0,
+                                                    APP_SHORT_NAME,  // class name
+                                                    APP_SHORT_NAME,  // app name
+                                                    // WS_VISIBLE | WS_SYSMENU |
+                                                    WS_OVERLAPPEDWINDOW,  // window style
+                                                    100, 100,             // x/y coords
+                                                    wr.right - wr.left,   // width
+                                                    wr.bottom - wr.top,   // height
+                                                    nullptr,              // handle to parent
+                                                    nullptr,              // handle to menu
+                                                    inst.h_instance,      // hInstance
+                                                    nullptr);             // no extra parameters
+    if (!inst.h_wnd) {
+        // It didn't work, so try to give a useful error:
+        THROW_ERR("Failed to create a window!");
+    }
+}
+
+static VkSurfaceKHR AppCreateWin32Surface(AppInstance &inst) {
+    VkWin32SurfaceCreateInfoKHR createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.hinstance = inst.h_instance;
+    createInfo.hwnd = inst.h_wnd;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateWin32SurfaceKHR(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateWin32SurfaceKHR", err);
+    return surface;
+}
+
+static void AppDestroyWin32Window(AppInstance &inst) { user32_handles->pfnDestroyWindow(inst.h_wnd); }
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+//-----------------------------------------------------------
+
+//----------------------------XCB----------------------------
+#ifdef VK_USE_PLATFORM_XCB_KHR
+static void AppCreateXcbWindow(AppInstance &inst) {
+    //--Init Connection--
+    const xcb_setup_t *setup;
+    xcb_screen_iterator_t iter;
+    int scr;
+
+    // API guarantees non-null xcb_connection
+    inst.xcb_connection = xcb_connect(nullptr, &scr);
+    int conn_error = xcb_connection_has_error(inst.xcb_connection);
+    if (conn_error) {
+        fprintf(stderr, "XCB failed to connect to the X server due to error:%d.\n", conn_error);
+        fflush(stderr);
+        xcb_disconnect(inst.xcb_connection);
+        inst.xcb_connection = nullptr;
+        return;
+    }
+
+    setup = xcb_get_setup(inst.xcb_connection);
+    iter = xcb_setup_roots_iterator(setup);
+    while (scr-- > 0) {
+        xcb_screen_next(&iter);
+    }
+
+    inst.xcb_screen = iter.data;
+    //-------------------
+
+    inst.xcb_window = xcb_generate_id(inst.xcb_connection);
+    xcb_create_window(inst.xcb_connection, XCB_COPY_FROM_PARENT, inst.xcb_window, inst.xcb_screen->root, 0, 0, inst.width,
+                      inst.height, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, inst.xcb_screen->root_visual, 0, nullptr);
+
+    xcb_intern_atom_cookie_t cookie = xcb_intern_atom(inst.xcb_connection, 1, 12, "WM_PROTOCOLS");
+    xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(inst.xcb_connection, cookie, 0);
+    free(reply);
+}
+
+static VkSurfaceKHR AppCreateXcbSurface(AppInstance &inst) {
+    if (!inst.xcb_connection) {
+        THROW_ERR("AppCreateXcbSurface failed to establish connection");
+    }
+
+    VkXcbSurfaceCreateInfoKHR xcb_createInfo;
+    xcb_createInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
+    xcb_createInfo.pNext = nullptr;
+    xcb_createInfo.flags = 0;
+    xcb_createInfo.connection = inst.xcb_connection;
+    xcb_createInfo.window = inst.xcb_window;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateXcbSurfaceKHR(inst.instance, &xcb_createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateXcbSurfaceKHR", err);
+    return surface;
+}
+
+static void AppDestroyXcbWindow(AppInstance &inst) {
+    if (!inst.xcb_connection) {
+        return;  // Nothing to destroy
+    }
+
+    xcb_destroy_window(inst.xcb_connection, inst.xcb_window);
+    xcb_disconnect(inst.xcb_connection);
+}
+#endif  // VK_USE_PLATFORM_XCB_KHR
+//-----------------------------------------------------------
+
+//----------------------------XLib---------------------------
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+static void AppCreateXlibWindow(AppInstance &inst) {
+    long visualMask = VisualScreenMask;
+    int numberOfVisuals{};
+
+    inst.xlib_display = XOpenDisplay(nullptr);
+    if (inst.xlib_display == nullptr) {
+        THROW_ERR("XLib failed to connect to the X server.\nExiting...");
+    }
+
+    XVisualInfo vInfoTemplate = {};
+    vInfoTemplate.screen = DefaultScreen(inst.xlib_display);
+    XVisualInfo *visualInfoBegin = XGetVisualInfo(inst.xlib_display, visualMask, &vInfoTemplate, &numberOfVisuals);
+    XVisualInfo *visualInfoEnd = visualInfoBegin + numberOfVisuals;
+    const Visual *rootVisual = DefaultVisual(inst.xlib_display, vInfoTemplate.screen);
+    const XVisualInfo *foundVisualInfo =
+        std::find_if(visualInfoBegin, visualInfoEnd, [rootVisual](const XVisualInfo &vi) { return vi.visual == rootVisual; });
+    const XVisualInfo *visualInfo = foundVisualInfo == visualInfoEnd ? visualInfoBegin : foundVisualInfo;
+    inst.xlib_window = XCreateWindow(inst.xlib_display, RootWindow(inst.xlib_display, vInfoTemplate.screen), 0, 0, inst.width,
+                                     inst.height, 0, visualInfo->depth, InputOutput, visualInfo->visual, 0, nullptr);
+
+    XSync(inst.xlib_display, false);
+    XFree(visualInfoBegin);
+}
+
+static VkSurfaceKHR AppCreateXlibSurface(AppInstance &inst) {
+    VkXlibSurfaceCreateInfoKHR createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.dpy = inst.xlib_display;
+    createInfo.window = inst.xlib_window;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateXlibSurfaceKHR(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateXlibSurfaceKHR", err);
+    return surface;
+}
+
+static void AppDestroyXlibWindow(AppInstance &inst) {
+    XDestroyWindow(inst.xlib_display, inst.xlib_window);
+    XCloseDisplay(inst.xlib_display);
+}
+#endif  // VK_USE_PLATFORM_XLIB_KHR
+//-----------------------------------------------------------
+
+//------------------------MACOS_MVK--------------------------
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+static void AppCreateMacOSWindow(AppInstance &inst) {
+    inst.macos_window = CreateMetalView(inst.width, inst.height);
+    if (inst.macos_window == nullptr) {
+        THROW_ERR("Could not create a native Metal view.\nExiting...");
+    }
+}
+
+static VkSurfaceKHR AppCreateMacOSSurface(AppInstance &inst) {
+    VkMacOSSurfaceCreateInfoMVK createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.pView = inst.macos_window;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateMacOSSurfaceMVK(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateMacOSSurfaceMVK", err);
+    return surface;
+}
+
+static void AppDestroyMacOSWindow(AppInstance &inst) { DestroyMetalView(inst.macos_window); }
+#endif  // VK_USE_PLATFORM_MACOS_MVK
+//-----------------------------------------------------------
+
+//------------------------METAL_EXT--------------------------
+#ifdef VK_USE_PLATFORM_METAL_EXT
+static void AppCreateMetalWindow(AppInstance &inst) {
+    inst.metal_window = CreateMetalView(inst.width, inst.height);
+    if (inst.metal_window == nullptr) {
+        THROW_ERR("Could not create a native Metal view.\nExiting...");
+    }
+}
+
+static VkSurfaceKHR AppCreateMetalSurface(AppInstance &inst) {
+    VkMetalSurfaceCreateInfoEXT createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.pLayer = static_cast<CAMetalLayer *>(GetCAMetalLayerFromMetalView(inst.metal_window));
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateMetalSurfaceEXT(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateMetalSurfaceEXT", err);
+    return surface;
+}
+
+static void AppDestroyMetalWindow(AppInstance &inst) { DestroyMetalView(inst.metal_window); }
+#endif  // VK_USE_PLATFORM_METAL_EXT
+//-----------------------------------------------------------
+
+//-------------------------WAYLAND---------------------------
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+static void wayland_registry_global(void *data, struct wl_registry *registry, uint32_t id, const char *interface,
+                                    uint32_t version) {
+    AppInstance &inst = *static_cast<AppInstance *>(data);
+    if (strcmp(interface, "wl_compositor") == 0) {
+        struct wl_compositor *compositor = (struct wl_compositor *)wl_registry_bind(registry, id, &wl_compositor_interface, 1);
+        inst.wayland_surface = wl_compositor_create_surface(compositor);
+    }
+}
+static void wayland_registry_global_remove(void *data, struct wl_registry *registry, uint32_t id) {}
+static const struct wl_registry_listener wayland_registry_listener = {wayland_registry_global, wayland_registry_global_remove};
+
+static void AppCreateWaylandWindow(AppInstance &inst) {
+    inst.wayland_display = wl_display_connect(nullptr);
+    struct wl_registry *registry = wl_display_get_registry(inst.wayland_display);
+    wl_registry_add_listener(wl_display_get_registry(inst.wayland_display), &wayland_registry_listener, static_cast<void *>(&inst));
+    wl_display_roundtrip(inst.wayland_display);
+    wl_registry_destroy(registry);
+}
+
+static VkSurfaceKHR AppCreateWaylandSurface(AppInstance &inst) {
+    VkWaylandSurfaceCreateInfoKHR createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.display = inst.wayland_display;
+    createInfo.surface = inst.wayland_surface;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateWaylandSurfaceKHR(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateWaylandSurfaceKHR", err);
+    return surface;
+}
+
+static void AppDestroyWaylandWindow(AppInstance &inst) { wl_display_disconnect(inst.wayland_display); }
+#endif  // VK_USE_PLATFORM_WAYLAND_KHR
+//-----------------------------------------------------------
+
+//-------------------------DIRECTFB--------------------------
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+static void AppCreateDirectFBWindow(AppInstance &inst) {
+    DFBResult ret;
+
+    ret = DirectFBInit(NULL, NULL);
+    if (ret) {
+        THROW_ERR("DirectFBInit failed to initialize DirectFB.\nExiting...");
+    }
+
+    ret = DirectFBCreate(&inst.dfb);
+    if (ret) {
+        THROW_ERR("DirectFBCreate failed to create main interface of DirectFB.\nExiting...");
+    }
+
+    DFBSurfaceDescription desc;
+    desc.flags = (DFBSurfaceDescriptionFlags)(DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
+    desc.caps = DSCAPS_PRIMARY;
+    desc.width = inst.width;
+    desc.height = inst.height;
+    ret = inst.dfb->CreateSurface(inst.dfb, &desc, &inst.directfb_surface);
+    if (ret) {
+        THROW_ERR("CreateSurface failed to create DirectFB surface interface.\nExiting...");
+    }
+}
+
+static VkSurfaceKHR AppCreateDirectFBSurface(AppInstance &inst) {
+    VkDirectFBSurfaceCreateInfoEXT createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.dfb = inst.dfb;
+    createInfo.surface = inst.directfb_surface;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateDirectFBSurfaceEXT(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateDirectFBSurfaceEXT", err);
+    return surface;
+}
+
+static void AppDestroyDirectFBWindow(AppInstance &inst) {
+    inst.directfb_surface->Release(inst.directfb_surface);
+    inst.dfb->Release(inst.dfb);
+}
+#endif  // VK_USE_PLATFORM_DIRECTFB_EXT
+//-----------------------------------------------------------
+
+//-------------------------ANDROID---------------------------
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+static void AppCreateAndroidWindow(AppInstance &inst) {}
+static VkSurfaceKHR AppCreateAndroidSurface(AppInstance &inst) {
+    VkAndroidSurfaceCreateInfoKHR createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
+    createInfo.pNext = NULL;
+    createInfo.flags = 0;
+    createInfo.window = (struct ANativeWindow *)(inst.window);
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateAndroidSurfaceKHR(inst.instance, &createInfo, NULL, &surface);
+    if (err) THROW_VK_ERR("vkCreateAndroidSurfaceKHR", err);
+    return surface;
+}
+static void AppDestroyAndroidWindow(AppInstance &inst) {}
+#endif
+//-----------------------------------------------------------
+//---------------------------GGP-----------------------------
+#ifdef VK_USE_PLATFORM_GGP
+static void AppCreateGgpWindow(AppInstance &inst) {}
+static VkSurfaceKHR AppCreateGgpSurface(AppInstance &inst) {
+    VkStreamDescriptorSurfaceCreateInfoGGP createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP;
+    createInfo.pNext = NULL;
+    createInfo.flags = 0;
+    createInfo.streamDescriptor = 1;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateStreamDescriptorSurfaceGGP(inst.instance, &createInfo, NULL, &surface);
+    if (err) THROW_VK_ERR("vkCreateStreamDescriptorSurfaceGGP", err);
+    return surface;
+}
+static void AppDestroyGgpWindow(AppInstance &inst) {}
+#endif
+//-----------------------------------------------------------
+//----------------------QNX SCREEN---------------------------
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+static void AppCreateScreenWindow(AppInstance &inst) {
+    int usage = SCREEN_USAGE_VULKAN;
+    int rc;
+
+    rc = screen_create_context(&inst.context, 0);
+    if (rc) {
+        THROW_ERR("Could not create a QNX Screen context.\nExiting...");
+    }
+    rc = screen_create_window(&inst.window, inst.context);
+    if (rc) {
+        THROW_ERR("Could not create a QNX Screen window.\nExiting...");
+    }
+    rc = screen_set_window_property_iv(inst.window, SCREEN_PROPERTY_USAGE, &usage);
+    if (rc) {
+        THROW_ERR("Could not set SCREEN_USAGE_VULKAN flag for QNX Screen window!\nExiting...");
+    }
+}
+
+static VkSurfaceKHR AppCreateScreenSurface(AppInstance &inst) {
+    VkScreenSurfaceCreateInfoQNX createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.context = inst.context;
+    createInfo.window = inst.window;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateScreenSurfaceQNX(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateScreenSurfaceQNX", err);
+    return surface;
+}
+
+static void AppDestroyScreenWindow(AppInstance &inst) {
+    screen_destroy_window(inst.window);
+    screen_destroy_context(inst.context);
+}
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+//-----------------------------------------------------------
+// ------------ Setup Windows ------------- //
+
+void SetupWindowExtensions(AppInstance &inst) {
+#if defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
+    bool has_display = true;
+    const char *display_var = getenv("DISPLAY");
+    if (display_var == nullptr || strlen(display_var) == 0) {
+        has_display = false;
+        std::cerr << "'DISPLAY' environment variable not set... skipping surface info\n";
+    }
+#endif
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    wl_display *wayland_display = wl_display_connect(nullptr);
+    bool has_wayland_display = false;
+    if (wayland_display != nullptr) {
+        wl_display_disconnect(wayland_display);
+        has_wayland_display = true;
+    }
+#endif
+
+//--WIN32--
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    SurfaceExtension surface_ext_win32;
+    if (inst.CheckExtensionEnabled(VK_KHR_WIN32_SURFACE_EXTENSION_NAME)) {
+        surface_ext_win32.name = VK_KHR_WIN32_SURFACE_EXTENSION_NAME;
+        surface_ext_win32.create_window = AppCreateWin32Window;
+        surface_ext_win32.create_surface = AppCreateWin32Surface;
+        surface_ext_win32.destroy_window = AppDestroyWin32Window;
+
+        inst.AddSurfaceExtension(surface_ext_win32);
+    }
+#endif
+//--XCB--
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    SurfaceExtension surface_ext_xcb;
+    if (inst.CheckExtensionEnabled(VK_KHR_XCB_SURFACE_EXTENSION_NAME)) {
+        surface_ext_xcb.name = VK_KHR_XCB_SURFACE_EXTENSION_NAME;
+        surface_ext_xcb.create_window = AppCreateXcbWindow;
+        surface_ext_xcb.create_surface = AppCreateXcbSurface;
+        surface_ext_xcb.destroy_window = AppDestroyXcbWindow;
+        if (has_display) {
+            inst.AddSurfaceExtension(surface_ext_xcb);
+        }
+    }
+#endif
+//--XLIB--
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    SurfaceExtension surface_ext_xlib;
+    if (inst.CheckExtensionEnabled(VK_KHR_XLIB_SURFACE_EXTENSION_NAME)) {
+        surface_ext_xlib.name = VK_KHR_XLIB_SURFACE_EXTENSION_NAME;
+        surface_ext_xlib.create_window = AppCreateXlibWindow;
+        surface_ext_xlib.create_surface = AppCreateXlibSurface;
+        surface_ext_xlib.destroy_window = AppDestroyXlibWindow;
+        if (has_display) {
+            inst.AddSurfaceExtension(surface_ext_xlib);
+        }
+    }
+#endif
+//--MACOS--
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+    SurfaceExtension surface_ext_macos;
+    if (inst.CheckExtensionEnabled(VK_MVK_MACOS_SURFACE_EXTENSION_NAME) && !inst.CheckExtensionEnabled("VK_EXT_metal_surface")) {
+        surface_ext_macos.name = VK_MVK_MACOS_SURFACE_EXTENSION_NAME;
+        surface_ext_macos.create_window = AppCreateMacOSWindow;
+        surface_ext_macos.create_surface = AppCreateMacOSSurface;
+        surface_ext_macos.destroy_window = AppDestroyMacOSWindow;
+
+        inst.AddSurfaceExtension(surface_ext_macos);
+    }
+#endif
+
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    SurfaceExtension surface_ext_metal;
+    if (inst.CheckExtensionEnabled(VK_EXT_METAL_SURFACE_EXTENSION_NAME)) {
+        surface_ext_metal.name = VK_EXT_METAL_SURFACE_EXTENSION_NAME;
+        surface_ext_metal.create_window = AppCreateMetalWindow;
+        surface_ext_metal.create_surface = AppCreateMetalSurface;
+        surface_ext_metal.destroy_window = AppDestroyMetalWindow;
+
+        inst.AddSurfaceExtension(surface_ext_metal);
+    }
+#endif
+//--WAYLAND--
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    SurfaceExtension surface_ext_wayland;
+    if (inst.CheckExtensionEnabled(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME)) {
+        surface_ext_wayland.name = VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME;
+        surface_ext_wayland.create_window = AppCreateWaylandWindow;
+        surface_ext_wayland.create_surface = AppCreateWaylandSurface;
+        surface_ext_wayland.destroy_window = AppDestroyWaylandWindow;
+        if (has_wayland_display) {
+            inst.AddSurfaceExtension(surface_ext_wayland);
+        }
+    }
+#endif
+//--DIRECTFB--
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    SurfaceExtension surface_ext_directfb;
+    if (inst.CheckExtensionEnabled(VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME)) {
+        surface_ext_directfb.name = VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME;
+        surface_ext_directfb.create_window = AppCreateDirectFBWindow;
+        surface_ext_directfb.create_surface = AppCreateDirectFBSurface;
+        surface_ext_directfb.destroy_window = AppDestroyDirectFBWindow;
+
+        inst.AddSurfaceExtension(surface_ext_directfb);
+    }
+#endif
+//--ANDROID--
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    SurfaceExtension surface_ext_android;
+    if (inst.CheckExtensionEnabled(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME)) {
+        surface_ext_android.name = VK_KHR_ANDROID_SURFACE_EXTENSION_NAME;
+        surface_ext_android.create_window = AppCreateAndroidWindow;
+        surface_ext_android.create_surface = AppCreateAndroidSurface;
+        surface_ext_android.destroy_window = AppDestroyAndroidWindow;
+
+        inst.AddSurfaceExtension(surface_ext_android);
+    }
+#endif
+//--GGP--
+#ifdef VK_USE_PLATFORM_GGP
+    SurfaceExtension surface_ext_ggp;
+    if (inst.CheckExtensionEnabled(VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME)) {
+        surface_ext_ggp.name = VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME;
+        surface_ext_ggp.create_window = AppCreateGgpWindow;
+        surface_ext_ggp.create_surface = AppCreateGgpSurface;
+        surface_ext_ggp.destroy_window = AppDestroyGgpWindow;
+
+        inst.AddSurfaceExtension(surface_ext_ggp);
+    }
+#endif
+//--QNX_SCREEN--
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    SurfaceExtension surface_ext_qnx_screen;
+    if (inst.CheckExtensionEnabled(VK_QNX_SCREEN_SURFACE_EXTENSION_NAME)) {
+        surface_ext_qnx_screen.name = VK_QNX_SCREEN_SURFACE_EXTENSION_NAME;
+        surface_ext_qnx_screen.create_window = AppCreateScreenWindow;
+        surface_ext_qnx_screen.create_surface = AppCreateScreenSurface;
+        surface_ext_qnx_screen.destroy_window = AppDestroyScreenWindow;
+
+        inst.AddSurfaceExtension(surface_ext_qnx_screen);
+    }
+#endif
+// TODO: add support for VK_KHR_display surfaces
+}
+
+// ---------- Surfaces -------------- //
+
+class AppSurface {
+  public:
+    AppInstance &inst;
+    VkPhysicalDevice phys_device;
+    SurfaceExtension surface_extension;
+
+    std::vector<VkPresentModeKHR> surf_present_modes;
+
+    std::vector<VkSurfaceFormatKHR> surf_formats;
+    std::vector<VkSurfaceFormat2KHR> surf_formats2;
+
+    VkSurfaceCapabilitiesKHR surface_capabilities{};
+    VkSurfaceCapabilities2KHR surface_capabilities2_khr{};
+    VkSurfaceCapabilities2EXT surface_capabilities2_ext{};
+
+    std::unique_ptr<surface_capabilities2_chain> chain_for_surface_capabilities2;
+
+    AppSurface(AppInstance &inst, AppGpu &gpu, VkPhysicalDevice phys_device, SurfaceExtension surface_extension)
+        : inst(inst), phys_device(phys_device), surface_extension(surface_extension) {
+        surf_present_modes =
+            GetVector<VkPresentModeKHR>("vkGetPhysicalDeviceSurfacePresentModesKHR", vkGetPhysicalDeviceSurfacePresentModesKHR,
+                                        phys_device, surface_extension.surface);
+
+        if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
+            const VkPhysicalDeviceSurfaceInfo2KHR surface_info2 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, nullptr,
+                                                                   surface_extension.surface};
+            VkSurfaceFormat2KHR init{};
+            init.sType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;
+            surf_formats2 = GetVectorInit<VkSurfaceFormat2KHR>(
+                "vkGetPhysicalDeviceSurfaceFormats2KHR", vkGetPhysicalDeviceSurfaceFormats2KHR, init, phys_device, &surface_info2);
+        } else {
+            surf_formats =
+                GetVector<VkSurfaceFormatKHR>("vkGetPhysicalDeviceSurfaceFormatsKHR", vkGetPhysicalDeviceSurfaceFormatsKHR,
+                                              phys_device, surface_extension.surface);
+        }
+
+        if (inst.CheckExtensionEnabled(VK_KHR_SURFACE_EXTENSION_NAME)) {
+            VkResult err = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(phys_device, surface_extension.surface, &surface_capabilities);
+            if (err) THROW_VK_ERR("vkGetPhysicalDeviceSurfaceCapabilitiesKHR", err);
+        }
+
+        if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
+            surface_capabilities2_khr.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR;
+            setup_surface_capabilities2_chain(surface_capabilities2_khr, chain_for_surface_capabilities2, inst, gpu);
+
+            VkPhysicalDeviceSurfaceInfo2KHR surface_info{};
+            surface_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
+            surface_info.surface = surface_extension.surface;
+#if defined(WIN32)
+            VkSurfaceFullScreenExclusiveWin32InfoEXT win32_fullscreen_exclusive_info{};
+            win32_fullscreen_exclusive_info.sType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT;
+            win32_fullscreen_exclusive_info.hmonitor = MonitorFromWindow(inst.h_wnd, MONITOR_DEFAULTTOPRIMARY);
+
+            surface_info.pNext = static_cast<void *>(&win32_fullscreen_exclusive_info);
+#endif  // defined(WIN32)
+            VkResult err = vkGetPhysicalDeviceSurfaceCapabilities2KHR(phys_device, &surface_info, &surface_capabilities2_khr);
+            if (err) THROW_VK_ERR("vkGetPhysicalDeviceSurfaceCapabilities2KHR", err);
+        }
+
+        if (inst.CheckExtensionEnabled(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)) {
+            surface_capabilities2_ext.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT;
+            surface_capabilities2_ext.pNext = nullptr;
+            VkResult err =
+                vkGetPhysicalDeviceSurfaceCapabilities2EXT(phys_device, surface_extension.surface, &surface_capabilities2_ext);
+            if (err) THROW_VK_ERR("vkGetPhysicalDeviceSurfaceCapabilities2EXT", err);
+        }
+    }
+
+    AppSurface(const AppSurface &) = delete;
+    const AppSurface &operator=(const AppSurface &) = delete;
+};
+
+// -------------------- Device Groups ------------------------//
+
+std::vector<VkPhysicalDeviceGroupProperties> GetGroups(AppInstance &inst) {
+    if (inst.CheckExtensionEnabled(VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME)) {
+        VkPhysicalDeviceGroupProperties group_props{};
+        group_props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
+        return GetVectorInit<VkPhysicalDeviceGroupProperties>("vkEnumeratePhysicalDeviceGroupsKHR",
+                                                              vkEnumeratePhysicalDeviceGroupsKHR, group_props, inst.instance);
+    }
+    return {};
+}
+
+std::vector<VkPhysicalDeviceProperties> GetGroupProps(AppInstance &inst, VkPhysicalDeviceGroupProperties group) {
+    std::vector<VkPhysicalDeviceProperties> props(group.physicalDeviceCount);
+
+    for (uint32_t i = 0; i < group.physicalDeviceCount; ++i) {
+        vkGetPhysicalDeviceProperties(group.physicalDevices[i], &props[i]);
+    }
+
+    return props;
+}
+
+util::vulkaninfo_optional<VkDeviceGroupPresentCapabilitiesKHR> GetGroupCapabilities(AppInstance &inst,
+                                                                                    VkPhysicalDeviceGroupProperties group) {
+    // Build create info for logical device made from all physical devices in this group.
+    std::vector<std::string> extensions_list = {VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_DEVICE_GROUP_EXTENSION_NAME};
+
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    for (const auto &extension : inst.AppGetPhysicalDeviceLayerExtensions(group.physicalDevices[0], nullptr)) {
+        if (std::string(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME) == extension.extensionName) {
+            extensions_list.push_back(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME);
+        }
+    }
+#endif
+
+    VkDeviceGroupDeviceCreateInfoKHR dg_ci = {VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, nullptr,
+                                              group.physicalDeviceCount, group.physicalDevices};
+
+    float queue_priority = 1.0f;
+
+    auto ext_list = get_c_str_array(extensions_list);
+
+    VkDeviceQueueCreateInfo q_ci = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, nullptr, 0, 0, 1, &queue_priority};
+    VkDeviceCreateInfo device_ci = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,   &dg_ci,         0, 1, &q_ci, 0, nullptr,
+                                    static_cast<uint32_t>(ext_list.size()), ext_list.data()};
+
+    VkDevice logical_device = VK_NULL_HANDLE;
+
+    VkResult err = vkCreateDevice(group.physicalDevices[0], &device_ci, nullptr, &logical_device);
+    if (err != VK_SUCCESS && err != VK_ERROR_EXTENSION_NOT_PRESENT) THROW_VK_ERR("vkCreateDevice", err);
+
+    if (err == VK_ERROR_EXTENSION_NOT_PRESENT) {
+        vkDestroyDevice(logical_device, nullptr);
+        return {};
+    }
+
+    VkDeviceGroupPresentCapabilitiesKHR group_capabilities = {VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, nullptr};
+
+    // If the KHR_device_group extension is present, write the capabilities of the logical device into a struct for later
+    // output to user.
+    err = vkGetDeviceGroupPresentCapabilitiesKHR(logical_device, &group_capabilities);
+    if (err) THROW_VK_ERR("vkGetDeviceGroupPresentCapabilitiesKHR", err);
+
+    vkDestroyDevice(logical_device, nullptr);
+
+    return {group_capabilities};
+}
+
+// -------------------- Device Setup ------------------- //
+
+const VkFormat color_format = VK_FORMAT_R8G8B8A8_UNORM;
+
+struct ImageTypeSupport {
+    enum class Type { regular, sparse, transient } type;
+    uint32_t memoryTypeBits;
+
+    bool Compatible(uint32_t memtype_bit) { return memoryTypeBits & memtype_bit; }
+};
+
+struct ImageTypeFormatInfo {
+    VkFormat format;
+    std::vector<ImageTypeSupport> type_support;
+};
+
+struct ImageTypeInfos {
+    VkImageTiling tiling;
+    std::vector<ImageTypeFormatInfo> formats;
+};
+
+VkImageCreateInfo GetImageCreateInfo(VkImageCreateFlags flags, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usages) {
+    return {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+            nullptr,
+            flags,
+            VK_IMAGE_TYPE_2D,
+            format,
+            {8, 8, 1},
+            1,
+            1,
+            VK_SAMPLE_COUNT_1_BIT,
+            tiling,
+            usages,
+            VK_SHARING_MODE_EXCLUSIVE,
+            0,
+            nullptr,
+            VK_IMAGE_LAYOUT_UNDEFINED};
+}
+
+util::vulkaninfo_optional<ImageTypeSupport> FillImageTypeSupport(AppInstance &inst, VkPhysicalDevice phys_device, VkDevice device,
+                                                                 ImageTypeSupport::Type img_type, VkImageCreateInfo image_ci) {
+    VkImageFormatProperties img_props;
+    VkResult res = vkGetPhysicalDeviceImageFormatProperties(phys_device, image_ci.format, image_ci.imageType, image_ci.tiling,
+                                                            image_ci.usage, image_ci.flags, &img_props);
+
+    if (res == VK_SUCCESS) {
+        ImageTypeSupport img_type_support{};
+        img_type_support.type = img_type;
+
+        VkImage dummy_img;
+        res = vkCreateImage(device, &image_ci, nullptr, &dummy_img);
+        if (res) THROW_VK_ERR("vkCreateImage", res);
+
+        VkMemoryRequirements mem_req;
+        vkGetImageMemoryRequirements(device, dummy_img, &mem_req);
+        img_type_support.memoryTypeBits = mem_req.memoryTypeBits;
+
+        vkDestroyImage(device, dummy_img, nullptr);
+        return img_type_support;
+    } else if (res == VK_ERROR_FORMAT_NOT_SUPPORTED) {
+        return {};  // return empty util::vulkaninfo_optional
+    }
+    THROW_VK_ERR("vkGetPhysicalDeviceImageFormatProperties", res);
+    return {};
+}
+
+struct FormatRange {
+    // the Vulkan standard version that supports this format range, or 0 if non-standard
+    APIVersion minimum_instance_version;
+
+    // The name of the extension that supports this format range, or NULL if the range
+    // is only part of the standard
+    const char *extension_name;
+
+    // The first and last supported formats within this range.
+    VkFormat first_format;
+    VkFormat last_format;
+};
+
+struct AppQueueFamilyProperties {
+    VkQueueFamilyProperties props;
+    uint32_t queue_index;
+    void *pNext = nullptr;  // assumes the lifetime of the pNext chain outlives this object, eg parent object must keep both alive
+    bool can_present = false;
+    bool can_always_present = true;
+    std::vector<std::pair<std::string, VkBool32>> present_support;
+    AppQueueFamilyProperties(AppInstance &inst, VkPhysicalDevice physical_device, VkQueueFamilyProperties family_properties,
+                             uint32_t queue_index, void *pNext = nullptr)
+        : props(family_properties), queue_index(queue_index), pNext(pNext) {
+        for (const auto &surface_ext : inst.surface_extensions) {
+            present_support.push_back({surface_ext.name, VK_FALSE});
+            VkResult err = vkGetPhysicalDeviceSurfaceSupportKHR(physical_device, queue_index, surface_ext.surface,
+                                                                &present_support.back().second);
+            if (err) THROW_VK_ERR("vkGetPhysicalDeviceSurfaceSupportKHR", err);
+            if (present_support.back().second) {
+                can_present = true;
+            } else {
+                can_always_present = false;
+            }
+        }
+    }
+};
+
+struct AppGpu {
+    AppInstance &inst;
+    uint32_t id{};
+    VkPhysicalDevice phys_device = VK_NULL_HANDLE;
+    APIVersion api_version;
+
+    VkPhysicalDeviceProperties props{};
+    VkPhysicalDeviceProperties2KHR props2{};
+
+    // VkPhysicalDeviceDriverProperties
+    VkDriverId driverID;
+    char driverName[VK_MAX_DRIVER_NAME_SIZE];
+    char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
+    VkConformanceVersion conformanceVersion;
+    // VkPhysicalDeviceIDProperties
+    uint8_t deviceUUID[VK_UUID_SIZE];
+    uint8_t driverUUID[VK_UUID_SIZE];
+    uint8_t deviceLUID[VK_LUID_SIZE];
+    uint32_t deviceNodeMask;
+    VkBool32 deviceLUIDValid;
+
+    bool found_driver_props = false;
+    bool found_device_id_props = false;
+
+    std::vector<VkQueueFamilyProperties> queue_props;
+    std::vector<VkQueueFamilyProperties2KHR> queue_props2;
+    std::vector<AppQueueFamilyProperties> extended_queue_props;
+
+    VkPhysicalDeviceMemoryProperties memory_props{};
+    VkPhysicalDeviceMemoryProperties2KHR memory_props2{};
+
+    std::vector<ImageTypeInfos> memory_image_support_types;
+
+    VkPhysicalDeviceFeatures features{};
+    VkPhysicalDeviceFeatures2KHR features2{};
+
+    std::vector<VkExtensionProperties> device_extensions;
+
+    VkDevice dev = VK_NULL_HANDLE;
+    VkPhysicalDeviceFeatures enabled_features{};
+
+    std::array<VkDeviceSize, VK_MAX_MEMORY_HEAPS> heapBudget;
+    std::array<VkDeviceSize, VK_MAX_MEMORY_HEAPS> heapUsage;
+
+    std::unique_ptr<phys_device_props2_chain> chain_for_phys_device_props2;
+    std::unique_ptr<phys_device_mem_props2_chain> chain_for_phys_device_mem_props2;
+    std::unique_ptr<phys_device_features2_chain> chain_for_phys_device_features2;
+    std::vector<std::unique_ptr<queue_properties2_chain>> chain_for_queue_props2;
+
+    std::vector<std::unique_ptr<AppVideoProfile>> video_profiles;
+
+    std::vector<AppDisplay> displays;
+    std::vector<AppDisplayPlane> display_planes;
+
+    AppGpu(AppInstance &inst, uint32_t id, VkPhysicalDevice phys_device, bool show_promoted_structs)
+        : inst(inst), id(id), phys_device(phys_device) {
+        vkGetPhysicalDeviceProperties(phys_device, &props);
+
+        // needs to find the minimum of the instance and device version, and use that to print the device info
+        api_version = APIVersion(props.apiVersion);
+
+        device_extensions = inst.AppGetPhysicalDeviceLayerExtensions(phys_device, nullptr);
+
+        vkGetPhysicalDeviceMemoryProperties(phys_device, &memory_props);
+
+        vkGetPhysicalDeviceFeatures(phys_device, &features);
+
+        uint32_t queue_count = 0;
+        vkGetPhysicalDeviceQueueFamilyProperties(phys_device, &queue_count, nullptr);
+        queue_props.resize(queue_count);
+        vkGetPhysicalDeviceQueueFamilyProperties(phys_device, &queue_count, queue_props.data());
+
+        if (inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+            // VkPhysicalDeviceProperties2
+            props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+            setup_phys_device_props2_chain(props2, chain_for_phys_device_props2, inst, *this, show_promoted_structs);
+
+            vkGetPhysicalDeviceProperties2KHR(phys_device, &props2);
+            prepare_phys_device_props2_twocall_chain_vectors(chain_for_phys_device_props2);
+            vkGetPhysicalDeviceProperties2KHR(phys_device, &props2);
+
+            // VkPhysicalDeviceMemoryProperties2
+            memory_props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR;
+            setup_phys_device_mem_props2_chain(memory_props2, chain_for_phys_device_mem_props2, *this);
+
+            vkGetPhysicalDeviceMemoryProperties2KHR(phys_device, &memory_props2);
+
+            // VkPhysicalDeviceFeatures2
+            features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
+            setup_phys_device_features2_chain(features2, chain_for_phys_device_features2, *this, show_promoted_structs);
+
+            vkGetPhysicalDeviceFeatures2KHR(phys_device, &features2);
+
+            // std::vector<VkPhysicalDeviceQueueFamilyProperties2>
+            uint32_t queue_prop2_count = 0;
+            vkGetPhysicalDeviceQueueFamilyProperties2KHR(phys_device, &queue_prop2_count, nullptr);
+            queue_props2.resize(queue_prop2_count);
+            chain_for_queue_props2.resize(queue_prop2_count);
+            for (size_t i = 0; i < queue_props2.size(); i++) {
+                queue_props2[i].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR;
+                setup_queue_properties2_chain(queue_props2[i], chain_for_queue_props2[i], *this);
+            }
+            vkGetPhysicalDeviceQueueFamilyProperties2KHR(phys_device, &queue_prop2_count, queue_props2.data());
+
+            if (CheckPhysicalDeviceExtensionIncluded(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME) ||
+                api_version >= VK_API_VERSION_1_2) {
+                void *place = props2.pNext;
+                while (place) {
+                    VkBaseOutStructure *structure = static_cast<VkBaseOutStructure *>(place);
+                    if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES) {
+                        VkPhysicalDeviceDriverProperties *driver_driver_properties =
+                            reinterpret_cast<VkPhysicalDeviceDriverProperties *>(structure);
+                        driverID = driver_driver_properties->driverID;
+                        memcpy(driverName, driver_driver_properties->driverName, VK_MAX_DRIVER_NAME_SIZE);
+                        memcpy(driverInfo, driver_driver_properties->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
+                        conformanceVersion = driver_driver_properties->conformanceVersion;
+                        found_driver_props = true;
+                    } else if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES) {
+                        VkPhysicalDeviceIDProperties *device_id_props = reinterpret_cast<VkPhysicalDeviceIDProperties *>(structure);
+                        memcpy(deviceUUID, device_id_props->deviceUUID, VK_UUID_SIZE);
+                        memcpy(driverUUID, device_id_props->driverUUID, VK_UUID_SIZE);
+                        memcpy(deviceLUID, device_id_props->deviceLUID, VK_LUID_SIZE);
+                        deviceNodeMask = device_id_props->deviceNodeMask;
+                        deviceLUIDValid = device_id_props->deviceLUIDValid;
+                        found_device_id_props = true;
+                    } else if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES) {
+                        VkPhysicalDeviceVulkan11Properties *vulkan_11_props =
+                            reinterpret_cast<VkPhysicalDeviceVulkan11Properties *>(structure);
+                        memcpy(deviceUUID, vulkan_11_props->deviceUUID, VK_UUID_SIZE);
+                        memcpy(driverUUID, vulkan_11_props->driverUUID, VK_UUID_SIZE);
+                        memcpy(deviceLUID, vulkan_11_props->deviceLUID, VK_LUID_SIZE);
+                        deviceNodeMask = vulkan_11_props->deviceNodeMask;
+                        deviceLUIDValid = vulkan_11_props->deviceLUIDValid;
+                        found_device_id_props = true;
+                    } else if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES) {
+                        VkPhysicalDeviceVulkan12Properties *vulkan_12_props =
+                            reinterpret_cast<VkPhysicalDeviceVulkan12Properties *>(structure);
+                        driverID = vulkan_12_props->driverID;
+                        memcpy(driverName, vulkan_12_props->driverName, VK_MAX_DRIVER_NAME_SIZE);
+                        memcpy(driverInfo, vulkan_12_props->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
+                        conformanceVersion = vulkan_12_props->conformanceVersion;
+                        found_driver_props = true;
+                    }
+                    place = structure->pNext;
+                }
+            }
+        }
+
+        // Use the queue_props2 if they exist, else fallback on vulkan 1.0 queue_props
+        int queue_index = 0;
+        if (queue_props2.size() > 0) {
+            for (auto &queue_prop : queue_props2) {
+                extended_queue_props.push_back(
+                    AppQueueFamilyProperties(inst, phys_device, queue_prop.queueFamilyProperties, queue_index++, queue_prop.pNext));
+            }
+        } else {
+            for (auto &queue_prop : queue_props) {
+                extended_queue_props.push_back(AppQueueFamilyProperties(inst, phys_device, queue_prop, queue_index++, nullptr));
+            }
+        }
+
+        if (features.sparseBinding) {
+            enabled_features.sparseBinding = VK_TRUE;
+        }
+
+        std::vector<const char *> extensions_to_enable;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        for (const auto &extension : device_extensions) {
+            if (std::string(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME) == extension.extensionName) {
+                extensions_to_enable.push_back(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME);
+            }
+        }
+#endif
+
+        const float queue_priority = 1.0f;
+        // pick the first queue index and hope for the best
+        const VkDeviceQueueCreateInfo q_ci = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, nullptr, 0, 0, 1, &queue_priority};
+        VkDeviceCreateInfo device_ci{};
+        device_ci.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+        device_ci.queueCreateInfoCount = 1;
+        device_ci.pQueueCreateInfos = &q_ci;
+        device_ci.enabledExtensionCount = static_cast<uint32_t>(extensions_to_enable.size());
+        device_ci.ppEnabledExtensionNames = extensions_to_enable.data();
+        device_ci.pEnabledFeatures = &enabled_features;
+
+        VkResult err = vkCreateDevice(phys_device, &device_ci, nullptr, &dev);
+        if (err) THROW_VK_ERR("vkCreateDevice", err);
+
+        const std::array<VkImageTiling, 2> tilings = {VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_TILING_LINEAR};
+        const std::array<VkFormat, 8> formats = {
+            color_format,      VK_FORMAT_D16_UNORM,         VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_D32_SFLOAT,
+            VK_FORMAT_S8_UINT, VK_FORMAT_D16_UNORM_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT,   VK_FORMAT_D32_SFLOAT_S8_UINT};
+
+        for (const VkImageTiling tiling : tilings) {
+            ImageTypeInfos image_type_infos;
+            image_type_infos.tiling = tiling;
+
+            for (const VkFormat format : formats) {
+                ImageTypeFormatInfo image_type_format_info;
+                image_type_format_info.format = format;
+
+                VkFormatProperties fmt_props;
+                vkGetPhysicalDeviceFormatProperties(phys_device, format, &fmt_props);
+                if ((tiling == VK_IMAGE_TILING_OPTIMAL && fmt_props.optimalTilingFeatures == 0) ||
+                    (tiling == VK_IMAGE_TILING_LINEAR && fmt_props.linearTilingFeatures == 0)) {
+                    continue;
+                }
+
+                VkImageCreateInfo image_ci_regular = GetImageCreateInfo(0, format, tiling, 0);
+                VkImageCreateInfo image_ci_transient =
+                    GetImageCreateInfo(0, format, tiling, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT);
+                VkImageCreateInfo image_ci_sparse =
+                    GetImageCreateInfo(VK_IMAGE_CREATE_SPARSE_BINDING_BIT, format, tiling, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
+
+                if (tiling == VK_IMAGE_TILING_LINEAR) {
+                    if (format == color_format) {
+                        image_ci_regular.usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+                        image_ci_transient.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+                    } else {
+                        // linear tiling is only applicable to color image types
+                        continue;
+                    }
+                } else {
+                    if (format == color_format) {
+                        image_ci_regular.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+                        image_ci_transient.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+
+                    } else {
+                        image_ci_regular.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+                        image_ci_transient.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+                    }
+                }
+
+                auto image_ts_regular_ret =
+                    FillImageTypeSupport(inst, phys_device, dev, ImageTypeSupport::Type::regular, image_ci_regular);
+                if (image_ts_regular_ret) {
+                    image_type_format_info.type_support.push_back(image_ts_regular_ret.value());
+                }
+                auto image_ts_transient_ret =
+                    FillImageTypeSupport(inst, phys_device, dev, ImageTypeSupport::Type::transient, image_ci_transient);
+                if (image_ts_transient_ret) {
+                    image_type_format_info.type_support.push_back(image_ts_transient_ret.value());
+                }
+
+                if (enabled_features.sparseBinding) {
+                    auto image_ts_sparse_ret =
+                        FillImageTypeSupport(inst, phys_device, dev, ImageTypeSupport::Type::sparse, image_ci_sparse);
+                    if (image_ts_sparse_ret) {
+                        image_type_format_info.type_support.push_back(image_ts_sparse_ret.value());
+                    }
+                }
+                image_type_infos.formats.push_back(image_type_format_info);
+            }
+            memory_image_support_types.push_back(image_type_infos);
+        }
+
+        // Memory //
+
+        struct VkBaseOutStructure *structure = NULL;
+        if (inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+            structure = (struct VkBaseOutStructure *)memory_props2.pNext;
+
+            while (structure) {
+                if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT &&
+                    CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_BUDGET_EXTENSION_NAME)) {
+                    VkPhysicalDeviceMemoryBudgetPropertiesEXT *mem_budget_props =
+                        reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(structure);
+                    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) {
+                        heapBudget[i] = mem_budget_props->heapBudget[i];
+                        heapUsage[i] = mem_budget_props->heapUsage[i];
+                    }
+                }
+
+                structure = structure->pNext;
+            }
+        }
+        // TODO buffer - memory type compatibility
+
+        // Video //
+        video_profiles = enumerate_supported_video_profiles(*this);
+
+        // Display //
+        display_planes = enumerate_display_planes(*this);
+        displays = enumerate_displays(*this, display_planes);
+
+        vkDestroyDevice(dev, nullptr);
+        dev = VK_NULL_HANDLE;
+    }
+    ~AppGpu() { vkDestroyDevice(dev, nullptr); }
+
+    AppGpu(const AppGpu &) = delete;
+    const AppGpu &operator=(const AppGpu &) = delete;
+
+    bool CheckPhysicalDeviceExtensionIncluded(std::string extension_to_check) const {
+        return std::any_of(
+            device_extensions.begin(), device_extensions.end(),
+            [extension_to_check](const VkExtensionProperties &prop) { return prop.extensionName == extension_to_check; });
+    }
+
+    // Helper function to determine whether a format range is currently supported.
+    bool FormatRangeSupported(const FormatRange &format_range) const {
+        // Formats from base vulkan spec
+        if (format_range.minimum_instance_version == 0 && format_range.extension_name == nullptr) {
+            return true;
+        }
+
+        // True if this extension is present
+        if (format_range.extension_name != nullptr) {
+            return CheckPhysicalDeviceExtensionIncluded(format_range.extension_name);
+        }
+
+        // True if standard and supported by both this instance and this GPU
+        if (inst.api_version >= format_range.minimum_instance_version &&
+            APIVersion(props.apiVersion) >= format_range.minimum_instance_version) {
+            return true;
+        }
+
+        // Otherwise, not supported.
+        return false;
+    }
+
+    VkPhysicalDeviceProperties GetDeviceProperties() {
+        if (inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+            return props2.properties;
+        } else {
+            return props;
+        }
+    }
+
+    // Vendor specific driverVersion mapping scheme
+    // If one isn't present, fall back to the standard Vulkan scheme
+    std::string GetDriverVersionString() {
+        uint32_t v = props.driverVersion;
+        if ((found_driver_props && driverID == VK_DRIVER_ID_NVIDIA_PROPRIETARY) ||
+            (!found_driver_props && props.deviceID == 4318)) {
+            return std::to_string((v >> 22) & 0x3ff) + "." + std::to_string((v >> 14) & 0x0ff) + "." +
+                   std::to_string((v >> 6) & 0x0ff) + "." + std::to_string(v & 0x003f);
+        } else if ((found_driver_props && driverID == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS)
+#if defined(WIN32)
+                   || (!found_driver_props && props.deviceID == 0x8086)  // only do the fallback check if running in windows
+#endif
+        ) {
+            return std::to_string(v >> 14) + "." + std::to_string(v & 0x3fff);
+        } else {
+            // AMD uses the standard vulkan scheme
+            return APIVersion(v).str();
+        }
+    }
+    const AppDisplay *FindDisplay(VkDisplayKHR handle) {
+        for (const auto &disp : displays) {
+            if (disp.properties.display == handle) {
+                return &disp;
+            }
+        }
+        return NULL;
+    }
+};
+
+std::vector<VkPhysicalDeviceToolPropertiesEXT> GetToolingInfo(AppGpu &gpu) {
+    if (vkGetPhysicalDeviceToolPropertiesEXT == nullptr) return {};
+    return GetVector<VkPhysicalDeviceToolPropertiesEXT>("vkGetPhysicalDeviceToolPropertiesEXT",
+                                                        vkGetPhysicalDeviceToolPropertiesEXT, gpu.phys_device);
+}
+
+std::vector<VkCooperativeMatrixPropertiesKHR> GetCooperativeMatrixInfo(AppGpu &gpu) {
+    if (vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR == nullptr) return {};
+    return GetVector<VkCooperativeMatrixPropertiesKHR>("vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR",
+                                                       vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, gpu.phys_device);
+}
+std::vector<VkTimeDomainKHR> GetTimeDomainInfo(AppGpu &gpu) {
+    if (vkGetPhysicalDeviceCalibrateableTimeDomainsKHR == nullptr) return {};
+    return GetVector<VkTimeDomainKHR>("vkGetPhysicalDeviceCalibrateableTimeDomainsKHR",
+                                      vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, gpu.phys_device);
+}
+std::vector<VkPhysicalDeviceFragmentShadingRateKHR> GetFragmentShadingRateInfo(AppGpu &gpu) {
+    if (vkGetPhysicalDeviceFragmentShadingRatesKHR == nullptr) return {};
+    return GetVector<VkPhysicalDeviceFragmentShadingRateKHR>("vkGetPhysicalDeviceFragmentShadingRatesKHR",
+                                                             vkGetPhysicalDeviceFragmentShadingRatesKHR, gpu.phys_device);
+}
+// Returns vector where each index maps to VkSampleCountFlagBits
+std::vector<VkMultisamplePropertiesEXT> GetSampleLocationInfo(AppGpu &gpu) {
+    if (vkGetPhysicalDeviceMultisamplePropertiesEXT == nullptr) return {};
+    std::vector<VkMultisamplePropertiesEXT> result;
+    // 7 covers VK_SAMPLE_COUNT_1_BIT to 64_BIT
+    for (uint32_t i = 0; i < 7; i++) {
+        const VkSampleCountFlagBits sample_count = (VkSampleCountFlagBits)(1 << i);
+        VkMultisamplePropertiesEXT props = {VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, nullptr};
+        vkGetPhysicalDeviceMultisamplePropertiesEXT(gpu.phys_device, sample_count, &props);
+        result.emplace_back(props);
+    }
+    return result;
+}
+
+// --------- Format Properties ----------//
+// can't use autogen because that is put in a header that we can't include because that header depends on stuff defined here
+bool operator==(const VkFormatProperties &a, const VkFormatProperties b) {
+    return a.linearTilingFeatures == b.linearTilingFeatures && a.optimalTilingFeatures == b.optimalTilingFeatures &&
+           a.bufferFeatures == b.bufferFeatures;
+}
+bool operator==(const VkFormatProperties3 &a, const VkFormatProperties3 b) {
+    return a.linearTilingFeatures == b.linearTilingFeatures && a.optimalTilingFeatures == b.optimalTilingFeatures &&
+           a.bufferFeatures == b.bufferFeatures;
+}
+
+struct PropFlags {
+    VkFormatProperties props;
+    VkFormatProperties3 props3;
+
+    bool operator==(const PropFlags &other) const { return props == other.props && props3 == other.props3; }
+};
+
+PropFlags get_format_properties(const AppGpu &gpu, VkFormat fmt) {
+    VkFormatProperties props;
+    vkGetPhysicalDeviceFormatProperties(gpu.phys_device, fmt, &props);
+
+    VkFormatProperties3 props3{};
+    props3.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
+
+    if (gpu.inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) &&
+        gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME)) {
+        VkFormatProperties2 props2{};
+        props2.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
+        props2.formatProperties = props;
+        props2.pNext = static_cast<void *>(&props3);
+        vkGetPhysicalDeviceFormatProperties2KHR(gpu.phys_device, fmt, &props2);
+    }
+    return {props, props3};
+}
+
+namespace std {
+template <>
+struct hash<VkFormatProperties> {
+    std::size_t operator()(const VkFormatProperties &k) const {
+        return ((std::hash<uint32_t>()(k.linearTilingFeatures) ^ (std::hash<uint32_t>()(k.optimalTilingFeatures) << 1)) >> 1) ^
+               (std::hash<uint32_t>()(k.bufferFeatures) << 1);
+    }
+};
+template <>
+struct hash<VkFormatProperties3> {
+    std::size_t operator()(const VkFormatProperties3 &k) const {
+        return ((std::hash<uint64_t>()(k.linearTilingFeatures) ^ (std::hash<uint64_t>()(k.optimalTilingFeatures) << 1)) >> 1) ^
+               (std::hash<uint64_t>()(k.bufferFeatures) << 1);
+    }
+};
+template <>
+struct hash<PropFlags> {
+    std::size_t operator()(const PropFlags &k) const {
+        return (std::hash<VkFormatProperties>()(k.props) ^ std::hash<VkFormatProperties3>()(k.props3)) >> 1;
+    }
+};
+}  // namespace std
diff --git a/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.md b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.md
new file mode 100644
index 00000000..17b4a8b6
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.md
@@ -0,0 +1,116 @@
+<!-- markdownlint-disable MD041 -->
+<!-- Copyright 2015-2023 LunarG, Inc. -->
+
+[![Khronos Vulkan][1]][2]
+
+[1]: https://vulkan.lunarg.com/img/Vulkan_100px_Dec16.png "https://www.khronos.org/vulkan/"
+[2]: https://www.khronos.org/vulkan/
+
+[![Creative Commons][3]][4]
+
+[3]: https://i.creativecommons.org/l/by-nd/4.0/88x31.png "Creative Commons License"
+[4]: https://creativecommons.org/licenses/by-nd/4.0/
+
+# Vulkan Information
+
+Vulkan Info is a program provided in the SDK which outputs various types of Vulkan information such as:
+
+- device properties of identified GPUs
+- Vulkan extensions supported by each GPU
+- recognized layers
+- supported image formats and format properties.
+
+## Running Vulkan Info
+
+After downloading and installing the SDK and setting up the runtime environment (see the [Getting Started](./getting_started.md#user-content-download-the-sdk) documentation) you will be able to run the Vulkan Info program from a command prompt.
+
+```
+vulkaninfo
+```
+
+Executing `vulkaninfo` without specifying the type of output will default to human-readable output to the console.
+
+Note: The Vulkan Info binary found in the Windows Vulkan SDK is named `vulkaninfoSDK.exe`. This is so it doesn't get confused with the Vulkan Info distributed by an IVH, as it is installed with the Vulkan Runtime Package. Since the SDK does not install Vulkan Info to the path, the Windows command line version used will be from the IHV distribution. To run the SDK version, either use the start menu shortcuts or navigate to the `VulkanSDK/Bin` directory and run `vulkaninfoSDK.exe` directly.
+
+```
+vulkaninfo --html
+```
+
+To organize output in a convenient HTML format use the `--html` option. Executing `vulkaninfo` with the `--html` option produces a file called `vulkaninfo.html` and can be found in your build directory.
+
+```
+vulkaninfo --json
+```
+Produce a json version of vulkaninfo output conforming to the [Vulkan Profiles schema](https://schema.khronos.org/vulkan/), saved as \"VP_VULKANINFO_[DEVICE_NAME]_[DRIVER_VERSION].json\", of the first gpu in the system.
+
+JSON output can be specified with the `-j` option and for multi-GPU systems, a single GPU can be targeted using the `--json=`*`GPU-number`* option where the *`GPU-number`* indicates the GPU of interest (e.g., `--json=0`). To determine the GPU number corresponding to a particular GPU, execute `vulkaninfo --summary` option (or none at all) first; doing so will summarize all GPUs in the system.
+
+Use the `--help` or `-h` option to produce a list of all available Vulkan Info options.
+
+```
+vulkaninfo - Summarize Vulkan information in relation to the current environment.
+
+USAGE:
+    vulkaninfo --summary
+    vulkaninfo -o <filename> | --output <filename>
+    vulkaninfo -j | -j=<gpu-number> | --json | --json=<gpu-number>
+    vulkaninfo --text
+    vulkaninfo --html
+    vulkaninfo --show-all
+    vulkaninfo --show-formats
+
+OPTIONS:
+[-h, --help]        Print this help.
+[--summary]         Show a summary of the instance and GPU's on a system.
+[-o <filename>, --output <filename>]
+                    Print output to a new file whose name is specified by filename.
+                    File will be written to the current working directory.
+[--text]            Produce a text version of vulkaninfo output to stdout. This is
+                    the default output.
+[--html]            Produce an html version of vulkaninfo output, saved as
+                    \"vulkaninfo.html\" in the directory in which the command
+                    is run.
+[-j, --json]        Produce a json version of vulkaninfo output conforming to the Vulkan
+                    Profiles schema, saved as
+                    \"VP_VULKANINFO_[DEVICE_NAME]_[DRIVER_VERSION].json\"
+                    of the first gpu in the system.
+[-j=<gpu-number>, --json=<gpu-number>]
+                    For a multi-gpu system, a single gpu can be targeted by
+                    specifying the gpu-number associated with the gpu of
+                    interest. This number can be determined by running
+                    vulkaninfo without any options specified.
+[--show-all]        Show everything (includes all the below options)
+[--show-formats]    Display the format properties of each physical device.
+                    Note: This only affects text output.
+[--show-tool-props] Show the active VkPhysicalDeviceToolPropertiesEXT that vulkaninfo finds.
+[--show-promoted-structs]
+                    Include structs promoted to core in pNext Chains.
+[--show-video-props]
+                    Display the video profile info, video capabilities and
+                    video format properties of each video profile supported
+                    by each physical device.
+                    Note: This only affects text output which by default
+                    only contains the list of supported video profile names.
+```
+
+### Windows
+
+Vulkan Info can also be found as a shortcut under the Start Menu.
+
+- `Start Menu -> Vulkan SDK`*`version`*`-> vulkaninfo`
+
+Note: In order to review and/or save the output produced when using Visual Studio execute `vulkaninfo` with the JSON option, you will have to redirect output to a file by modifying the command line arguments in the debug options.
+
+Note: The Vulkan Info binary found in the Vulkan SDK is renamed to `vulkaninfoSDK.exe`. This was done to demark any Vulkan Info version installed by the Vulkan Runtime Package, which is from an IHV distribution. When using command line on Windows, the Vulkan info version used will be from the IHV distribution, not the SDK. To run the SDK version, either use the start menu shortcuts or navigate to the `VulkanSDK/Bin` directory and run `vulkaninfoSDK.exe` directly.
+
+### iOS Devices
+
+Vulkan Info is now avaialble for iOS devices, but must be built manually.
+
+The Vulkan Info project contains a folder at [vulkaninfo/ios](https://github.com/KhronosGroup/Vulkan-Tools/tree/main/vulkaninfo/iOS) that contains an XCode project that will build Vulkan Info for iOS devices. In order to deploy to an iOS device, the developer must be a member of the [Apple Developer Program](https://developer.apple.com/programs/). In addition, Vulkan Info makes use of the [MoltenVK](https://github.com/KhronosGroup/MoltenVK) libraries, which is a seperate project from Vulkan-Tools and you will need to add the MoltenVK libraries to your XCode project manually. See the [LunarG Getting Started with the macOS SDK](https://vulkan.lunarg.com/doc/sdk/latest/mac/getting_started.html) guide for more information about using MoltenVK in the Vulkan SDK.
+
+When Vulkan Info is run on an iOS device, it will create the standard vulkaninfo.json file and also a portability.json file. An HTML file is also created, and is displayed in a webview on the iOS device when the application is run. These files are located on the iOS device, and are available via the [iOS application file sharing mechanism](https://support.apple.com/en-us/HT201301) via iTunes for Windows or macOS. You can also access these files using the macOS Finder or Windows Explorer when the device is attached to the host computer via a USB cable. Select the device, and navigate to the "vulkaninfo" folder to access these files. There is currently no supported means to access these files on an iOS device from a Linux host computer.
+
+
+
+
diff --git a/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.rc.in b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.rc.in
new file mode 100644
index 00000000..dd5562f5
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.rc.in
@@ -0,0 +1,58 @@
+//
+// Copyright (c) 2018-2023 The Khronos Group Inc.
+// Copyright (c) 2018-2023 Valve Corporation
+// Copyright (c) 2018-2023 LunarG, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: Lenny Komow <david@lunarg.com>
+// Author: Charles Giessen <charles@lunarg.com>
+
+#include "winres.h"
+
+// All set through CMake
+#define VER_FILE_VERSION ${VULKANINFO_VER_FILE_VERSION}
+#define VER_FILE_VERSION_STR ${VULKANINFO_VER_FILE_VERSION_STR}
+#define VER_FILE_DESCRIPTION_STR ${VULKANINFO_VER_FILE_DESCRIPTION_STR}
+#define VER_COPYRIGHT_STR "Copyright (C) 2015-${VULKANINFO_CUR_COPYRIGHT_STR}"
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION VER_FILE_VERSION
+ PRODUCTVERSION VER_FILE_VERSION
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS VS_FF_DEBUG
+#else
+ FILEFLAGS 0x0L
+#endif
+
+ FILEOS 0x00000L
+ FILETYPE VFT_DLL
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "04090000"
+        BEGIN
+            VALUE "FileDescription", VER_FILE_DESCRIPTION_STR
+            VALUE "FileVersion", VER_FILE_VERSION_STR
+            VALUE "LegalCopyright", VER_COPYRIGHT_STR
+            VALUE "ProductName", "Vulkaninfo"
+            VALUE "ProductVersion", VER_FILE_VERSION_STR
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 0000
+    END
+END
diff --git a/tools/Vulkan-Tools/vulkaninfo/vulkaninfo_functions.h b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo_functions.h
new file mode 100644
index 00000000..2876155c
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo_functions.h
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2025-2026 The Khronos Group Inc.
+ * Copyright (c) 2025-2026 Valve Corporation
+ * Copyright (c) 2025-2026 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Charles Giessen <charles@lunarg.com>
+ *
+ */
+#pragma once
+
+// Need to include relevant system headers to open the dynamic library
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(__APPLE__)
+#include <stdlib.h>
+#include <dlfcn.h>
+#else
+#include <dlfcn.h>
+#endif
+
+// We are providing storage for all functions, make sure the vulkan headers doesn't conflate with ours.
+#if !defined(VK_NO_PROTOTYPES)
+#define VK_NO_PROTOTYPES
+#endif
+
+#include <vulkan/vulkan.h>
+
+void* vulkan_library;
+
+// Global Functions
+PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
+PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
+PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
+PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion;
+PFN_vkCreateInstance vkCreateInstance;
+
+// Per-platform Instance functions
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT;
+#endif
+#if defined(VK_USE_PLATFORM_MACOS_MVK)
+PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK;
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX;
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY)
+PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT;
+#endif
+#if defined(VK_USE_PLATFORM_GGP)
+PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP;
+#endif
+// Instance functions
+PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT;
+PFN_vkCreateDevice vkCreateDevice;
+PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT;
+PFN_vkDestroyInstance vkDestroyInstance;
+PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
+PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties;
+PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR;
+PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR;
+PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR;
+PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR;
+PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures;
+PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties;
+PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
+PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
+PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
+PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR;
+PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR;
+PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
+PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR;
+PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR;
+PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR;
+PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR;
+PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR;
+PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR;
+PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties;
+PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR;
+PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR;
+PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR;
+PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR;
+PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
+PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT;
+PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT;
+PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR;
+PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR;
+PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR;
+PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR;
+PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT;
+
+// Device functions
+PFN_vkCreateImage vkCreateImage;
+PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
+PFN_vkDestroyImage vkDestroyImage;
+PFN_vkDestroyDevice vkDestroyDevice;
+
+#define LOAD_INSTANCE_FUNCTION(instance, function) function = (PFN_##function)vkGetInstanceProcAddr(instance, #function)
+
+static VkResult load_vulkan_library() {
+    vulkan_library = NULL;
+#if defined(WIN32)
+    HMODULE library = LoadLibraryA("vulkan-1.dll");
+    if (library == NULL) return VK_ERROR_INITIALIZATION_FAILED;
+
+    vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)(void (*)(void))GetProcAddress(library, "vkGetInstanceProcAddr");
+#elif defined(__APPLE__)
+    void* library = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL);
+    if (library == NULL) {
+        library = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL);
+    }
+    if (library == NULL && getenv("DYLD_FALLBACK_LIBRARY_PATH") == NULL) {
+        library = dlopen("/usr/local/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL);
+        if (library == NULL) {
+            library = dlopen("/usr/local/lib/libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL);
+        }
+    }
+    if (library == NULL) {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(library, "vkGetInstanceProcAddr");
+#else  // Assume everything else supports dlopen
+    void* library = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL);
+    if (library == NULL) library = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL);
+    if (library == NULL) {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+    vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(library, "vkGetInstanceProcAddr");
+#endif
+    if (vkGetInstanceProcAddr == NULL) {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+    vulkan_library = library;
+    LOAD_INSTANCE_FUNCTION(NULL, vkEnumerateInstanceExtensionProperties);
+    LOAD_INSTANCE_FUNCTION(NULL, vkEnumerateInstanceLayerProperties);
+    LOAD_INSTANCE_FUNCTION(NULL, vkEnumerateInstanceVersion);
+    LOAD_INSTANCE_FUNCTION(NULL, vkCreateInstance);
+
+    return VK_SUCCESS;
+}
+
+static void unload_vulkan_library() {
+    if (vulkan_library != NULL) {
+#if defined(WIN32)
+        FreeLibrary((HMODULE)vulkan_library);
+#else
+        dlclose(vulkan_library);
+#endif
+        vulkan_library = NULL;
+    }
+}
+
+static void load_vulkan_instance_functions(VkInstance instance) {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateWin32SurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateWaylandSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateAndroidSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateXlibSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateXcbSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateMetalSurfaceEXT);
+#endif
+#if defined(VK_USE_PLATFORM_MACOS_MVK)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateMacOSSurfaceMVK);
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateScreenSurfaceQNX);
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateDisplayPlaneSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateDirectFBSurfaceEXT);
+#endif
+#if defined(VK_USE_PLATFORM_GGP)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateStreamDescriptorSurfaceGGP);
+#endif
+
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateDebugReportCallbackEXT);
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateDevice);
+    LOAD_INSTANCE_FUNCTION(instance, vkDestroyDebugReportCallbackEXT);
+    LOAD_INSTANCE_FUNCTION(instance, vkDestroyInstance);
+    LOAD_INSTANCE_FUNCTION(instance, vkDestroySurfaceKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkEnumerateDeviceExtensionProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayModePropertiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayPlaneCapabilitiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayPlaneSupportedDisplaysKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceDisplayPlanePropertiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceDisplayPropertiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFeatures);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFormatProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceMemoryProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceQueueFamilyProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceFormatsKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfacePresentModesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceSupportKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceVideoCapabilitiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceFormats2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceCapabilities2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceVideoFormatPropertiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkEnumeratePhysicalDeviceGroupsKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetDeviceGroupPresentCapabilitiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceImageFormatProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceProperties2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceMemoryProperties2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFeatures2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceQueueFamilyProperties2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkEnumeratePhysicalDevices);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceCapabilities2EXT);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceToolPropertiesEXT);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFormatProperties2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceCalibrateableTimeDomainsKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFragmentShadingRatesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceMultisamplePropertiesEXT);
+
+    // Load device functions using vkGetInstanceProcAddr, vulkaninfo doesn't care about the extra indirection it causes
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateImage);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetImageMemoryRequirements);
+    LOAD_INSTANCE_FUNCTION(instance, vkDestroyImage);
+    LOAD_INSTANCE_FUNCTION(instance, vkDestroyDevice);
+}
+
+#undef LOAD_INSTANCE_FUNCTION